How can I consistent use carrying functions?

1

If I want to write my code with functional style I will use carrying. It needs for construct my app like a building with bricks.

Correct example:

let sum = (a, b) => a + b

let add5 = sum(5)

let _ = sum(10)
let _ = 10->sum

Incorrect:

type user = {
	name: string,
  	age: int,
}

let updateUserAge = (age, user) => {...user, age}

let setAgeToUser = updateUserAge(18)

let user: user = { name: "Jake", age: 10 }
let _ = user->setAgeToUser // ok
let _ = user->updateUserAge(18) // error

If I could use composition function (not pipeline) then I could write consistent functional code like in ELM or Haskell.
Maybe I don’t know how it write beatiful. I don’t want write like there:

let updateUserAge = (user, age) => {...user, age}

let setAgeToUser = x => updateUserAge(x, 18)

let user: user = { name: "Jake", age: 10 }
let _ = user->setAgeToUser // ok
let _ = user->updateUserAge(18) // ok

x => (x, ..) – It looks bad.

2

Why did you remove composition operator?

3

The docs says refer to this blog.
https://www.javierchavarri.com/data-first-and-data-last-a-comparison/

I guess this answers the question of why ReScript chose data-first.

2 Likes
4

Thanks. I have read it. But I wanted to write more beatuiful :slight_smile:

5

So. I Found such decision:

let setAgeToUser = updateUserAge(_, 18)

It looks better than let setAgeToUser = x => updateUserAge(x, 18)

2 Likes
6

Another option is to use labeled arguments:

let updateUserAge = (user, ~age) => {...user, age}
let setAgeToUser = updateUserAge(~age=18)
2 Likes
7

Labeled arguments is ok for functions with more than 3 arguments. But if it has less than 3 - then it’s bad idea (too lot of code for simple action)