0

for example

let When true d = d
let foo = () |> When false

So I've got side effect I don't like because it's error: MatchFailureException

I know that I can have good side effect here: let foo = if false then ()

But warning Incomplete pattern matches on this expression. tells me like I can add what I need. I just don't know how or if it possible? Else way why I even can use values as arguments?

btw: I know that I can write When b d = if b then d else () but question is more general.

added explain in haskell

    let wh :: Bool -> IO () -> IO ()
        wh True f = f
        wh False f = return ()
cnd
  • 32,616
  • 62
  • 183
  • 313

2 Answers2

4

When you write something like:

let When true d = d

You're telling F# to create a function that takes two arguments and you're matching the two arguments against patterns true and d, respectively. The true pattern is incomplete and fails when the input is not a true value. The d pattern is variable binding and it always succeeds.

The fact that you can use incomplete patterns in arguments of function declarations is not particularly useful (but I suppose you could use a more complex pattern that the compiler just cannot verify).

Incomplete patterns really only make sense when you're using match or when you're using function. The function keyword gives you something like guards in other languages - but it only works with functions taking single argument. If you change When to accept a tuple, you can write:

let When = function
  | true, f -> f()
  | false, _ -> ()

Alternatively, you could reverse the order of arguments (and use currying) as in the answer from Vesa.A.J.K.

Tomas Petricek
  • 240,744
  • 19
  • 378
  • 553
  • Thank you but I mostly wanted to understand more behavoir where I pass value as in example. I understand that it's currently not supported to work as I want it to work but then is there ways where such things could be useful? Or is it just something incomplete? – cnd Sep 23 '14 at 12:19
2

The fact that this is allowed is more of a quirk of the spec, and is really so you can do things like

let (a,b) = 1,2

Your question isn't particularly clear, but I think you are looking for something like 

let 1 |2 = 1

Essentially the syntax is the same as after match except you don't need the first |

Side note, this allows for the craziest piece of F# code that I wrote in a while:

let 1 = 2

This will compile (with a warning) but fail at runtime.

John Palmer
  • 25,356
  • 3
  • 48
  • 67
  • but I have it as argument, I've got operator `When` may you show how can I use such syntax with my `When`? – cnd Sep 23 '14 at 11:59
  • or... is it just not designed for use as arguments? At least it works when I do `let foo = () |> When true` – cnd Sep 23 '14 at 12:05
  • I really don't understand what you are trying to do here. Are you trying to define a function called when? Or just to use it in some weird way? – John Palmer Sep 23 '14 at 12:09
  • Sorry, I've added explaination of what I want in haskell – cnd Sep 23 '14 at 12:14