Back to Questions
1.8k
views8
comments
misuse f#, function with named inputs & defualt values, several named outputs
f#

hi,

i want to somehow write functions with named inputs & named outputs. the inputs come with default values.
my current approach is to use records.

type divide_in =
{ Dividend : float
Divisor : float }
let divide_default =
{ Dividend = 1.0;
Divisor = 1.0 }
type divide_out =
{ Quotient : float
OK : bool }
let divide divide_in =
{ Quotient = divide_in.Dividend / divide_in.Divisor
OK = divide_in.Divisor <> 0.0 }
type divide = divide_in -> divide_out

// when using the function we don't need to know the parameter order nor the defaults:

let x1 = {divide_default with Dividend = 4.0}
let y1 = divide x1

printfn "%g / %g = %g, OK : %b" x1.Dividend x1.Divisor y1.Quotient y1.OK;;

let x2 = {divide_default with Divisor = 0.0}
let y2 = divide x2

printfn "%g / %g = %g, OK : %b" x2.Dividend x2.Divisor y2.Quotient y2.OK;;

this works so far:
4 / 1 = 4, OK : true
1 / 0 = Infinity, OK : false

however i don't want to give up other language features like type inference...

is there any possibility to use generic types in records?

type add_in =

{ Input1: _

Input2: _ }

is not allowed. why?

thanks,
Sebastian Gregor

.

I am also unclear what you really want. Inputs to method can be named and optional, see 8.4.5 and 8.4.6

[link:research.microsoft.com]

[link:research.microsoft.com]

And if you want to name portions of a result, you can return a record, as you are doing.

By on 1/31/2009 12:26 PM ()

thx brianmcn!

i'm still a beginner without good book and strange ideas what to try.

so thx a lot. i will have a deeper look at that

By on 1/31/2009 1:06 PM ()

Hi,

Is this what you're looking for?

1
2

type add_in<'a,'b> = { Input1:'a; Input2:'b }

Kurt

By on 1/31/2009 12:06 PM ()

hi, thx, maybe,

however i have other problems with that...

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

type add_in<'a,'b> = 
  { Input1: 'a
    Input2: 'b }
let add_s_default =
  { Input1 = "hello";
    Input2 = " world" }
let add_i_default =
  { Input1 = 0;
    Input2 = 0 }
let add_f_default =
  { Input1 = 0.0;
    Input2 = 0.0 }
type add_out<'a> = 
  { Output: 'a }
type add<'a> = add_in<'a, 'a> -> add_out<'a>  
let add add_in = { Output = add_in.Input1 + add_in.Input2 }

// when using the function we don't need to know the parameter order nor the defaults:

let x1 = {add_s_default with Input1 = "real"}


let y1 = add x1


let x2 = {add_i_default with Input2 = 7}
let y2 = add x2

it doesn't work. fsi says:

stdin(607,14): error FS0001: Type mismatch. Expecting a
add_in<string,string>
but given a
add_in<int,int>.
The type 'string' does not match the type 'int'.

somehow the type of the function is fixed after binding x1.Input1 to a string.
any idea about that?

or does anybody know how to do (/simulate)
* named parameters
* named outputs
* default values for inputs
with another technique?

thanks,
Sebastian Gregor

By on 1/31/2009 1:00 PM ()

(even if that might not be the way to go for what i initially wanted to do...)

why can't i compile this code:

type add_in<'a> =
{ Input1: 'a
Input2: 'a }
type add_out<'a> =
{ Output: 'a }
let add<'a> add_in = { Output = add_in.Input1 + add_in.Input2 }
type add<'a> = add_in<'a> -> add_out<'a>

let x1 = {Input1 = "a"; Input2 = "b"}
let y1 = add<string> x1
let x2 = {Input1 = 3; Input2 = 7}
let y2 = add<int> x2

type inference seems not to work like i thought it would.
for

let adds = add<string>
let addi = add<int>

the fsi returns

val adds : (add_in<int> -> add_out<int>)
val addi : (add_in<int> -> add_out<int>)

which makes no sense for me.
i had expected "adds" to be of type (add_in<string> -> add_out<string>)

thx for clarification

By on 2/1/2009 11:08 AM ()

You've stumbled headlong into a very complicated part of the type system.

'+' is overloaded in a somewhat magical way (using 'inline' and '^' and static member constraints), and so you cannot expect to use '+' on objects of type 'a (forall 'a).

As a result, F# infers that the right-hand-side of the 'let' is using '+' on 'int's, and the explicit type parameter <'a> on the let is effectively being ignored. If you try to add more type annotations to that line, a la

let add<'a> (add_in:add_in<'a>) : add_out<'a> = { Output = add_in.Input1 + add_in.Input2 }

the compiler may at least point to the '+' expression as the source of the problem. If you get rid of the +,

let add<'a> (add_in:add_in<'a>) : add_out<'a> = { Output = add_in.Input1 }

then the types work out.

If you want to make this particular example work, you'll have to learn more about how to write code that is generic with respect to overloaded '+'.

By on 2/1/2009 11:38 AM ()

hey, thx

the funny thing is that i tried to test my idea with the most basic function i could think of (adding things). however i can somehow understand that the polymorphism of the + operator looks so natural because a lot of work has been done to make it look simple...

so i might just try another example and put the polymophism aside, but i would still like to also stick at that problem for a moment to get the head free again. i tried some other code:

type Add() =
static member Eval(first,second) = (first+second)

let a = Add.Eval(first=1,second=2);;
let b = Add.Eval(first="hallo ",second="welt");;

but since the problem is the + operator itself i again failed.

so if you can point me into the direction where i need to read and learn i would be happy and try further.

thank you

By on 2/1/2009 4:56 PM ()

Check out

[link:cs.hubfs.net]

[link:cs.hubfs.net]

[link:cs.hubfs.net]

for some leads

By on 2/2/2009 5:00 AM ()

    Topic tags

    IntelliFactory Offices Copyright (c) 2011-2012 IntelliFactory. All rights reserved.
    Home | Products | Consulting | Trainings | Blogs | Jobs | Contact Us | Terms of Use | Privacy Policy | Cookie Policy     		Built with WebSharper