title: The result of this expression is implicitly ignored. Consider using 'ignore' e.g. 'expr |> ignore', or ' e.g. 'let result = expr'
body: <p>I'm trying to build <code>F#</code> equivalent code for the <code>Python</code> code appearing <a href="https://grisha.org/blog/2016/02/17/triple-exponential-smoothing-forecasting-part-iii/" rel="nofollow noreferrer">here</a>, I've the below code:</p>
  
  <pre><code>let tripleExponentialSmoothing series slen alpha beta gamma nPreds =
      let result : float list = []
      let mutable smooth = 0.
      let mutable trend = 0.
      let seasonals = initialSeasonalComponents series 12
      for i in 0..(series.Length+nPreds-1) do
      match i with
      | 0 -&gt;     // initial values        
          smooth &lt;- series |&gt; Array.head |&gt; float
          trend &lt;- initialTrend series slen
          result |&gt; List.append [series |&gt; Array.head |&gt; float] |&gt; ignore
      | i when i &gt;= series.Length -&gt; // we are forecasting
          let m = i - series.Length + 1
          result |&gt; List.append [(smooth + float m * trend) + seasonals.Item(i%slen)] |&gt; ignore
      | _ -&gt; 
          let v = series |&gt; Array.head  |&gt; float
          let lastSmooth = smooth
          smooth &lt;- alpha*(v-seasonals.Item(i%slen)) + (1.-alpha)*(smooth+trend)
          trend &lt;- beta * (smooth-lastSmooth) + (1.-beta)*trend
          seasonals.Item(i%slen) &lt;- gamma*(v-smooth) + (1.-gamma)*seasonals.Item(i%slen)
          result |&gt; List.append [smooth + trend + seasonals.Item(i%slen)] |&gt; ignore
      result
  </code></pre>
  
  <p>For which I got the below error:</p>
  
  <blockquote>
    <p>warning FS0020: The result of this expression is implicitly ignored.
    Consider using 'ignore' to discard this value explicitly, e.g. 'expr
    |> ignore', or 'let' to bind the result to a name, e.g. 'let result =
    expr'.</p>
  </blockquote>
  
  <p>I tried to write the above as conversion of the below <code>Python</code> code:</p>
  
  <pre><code>def triple_exponential_smoothing(series, slen, alpha, beta, gamma, n_preds):
      result = []
      seasonals = initial_seasonal_components(series, slen)
      for i in range(len(series)+n_preds):
          if i == 0: # initial values
              smooth = series[0]
              trend = initial_trend(series, slen)
              result.append(series[0])
              continue
          if i &gt;= len(series): # we are forecasting
              m = i - len(series) + 1
              result.append((smooth + m*trend) + seasonals[i%slen])
          else:
              val = series[i]
              last_smooth, smooth = smooth, alpha*(val-seasonals[i%slen]) + (1-alpha)*(smooth+trend)
              trend = beta * (smooth-last_smooth) + (1-beta)*trend
              seasonals[i%slen] = gamma*(val-smooth) + (1-gamma)*seasonals[i%slen]
              result.append(smooth+trend+seasonals[i%slen])
      return result
  </code></pre>
  
  <p>What the wrong things I did, and what is the correct code equivalent to the mentioned <code>Python</code>'s one.</p>