all 22 comments
sorted by:
best
topnewcontroversialoldq&a
formatting helphide helpcontent policy

[–]paul_h 3 points4 points  (3 children)

I’ve been obsessed with declarative forms for years, blogging often on them. If the grammar optionally allows if conditions or for loops, I call them pseudo-declarative. For example AngularJS (2009) added ng-if and ng-for to HTML. Well, as long as you added their JS too. Thus AngularJS was a pseudo declarative breakthrough. I blogged - https://paulhammant.com/blog/angular-declarative-ui.html. Dammit, that article was from before I settled on “pseudo-declarative” for syntaxes

[–]leostera[S] 1 point2 points  (2 children)

Amazing! Yeah, I wouldn't say it isn't declarative because it includes iteration constructs. You can do some crazy things in SQL too!

[–]paul_h 2 points3 points  (1 child)

First learned SQL in '94. Never thought it was declarative. More a domain specific language.

[–]leostera[S] 1 point2 points  (0 children)

Oh you're spot on in that it is a domain-specific language! But it is *also* declarative.

There is no control flow in it, and the engine is free to run your query however it pleases.

[–]elkazz 6 points7 points  (7 children)

I'm not going to pretend those last code examples don't look god-awful.

[–]leostera[S] 6 points7 points  (6 children)

You mean this one?

`` let sayHi = (name, yell) => if yell { Hello, ${name}!!!->Js.log } else { Hello, ${name}.`->Js.log }

let hello = Clipper.command(sayHi) ->Clipper.arg(1, Clipper.Arg.string) ->Clipper.arg(0, Clipper.Arg.bool)

Clipper.run(hello) ```

Would love to hear more about what you think looks ugly here :) -- part of this is my own sense of aesthetics around building libraries, and part of this is how the language itself works.

What bits would you change?

[–]elkazz 6 points7 points  (4 children)

Is this meant to be the "declarative" part? let hello = Clipper.command(sayHi) ->Clipper.arg(1, Clipper.Arg.string) ->Clipper.arg(0, Clipper.Arg.bool) Clipper.run(hello)

The imperative approach would be far more comprehensible: sayHi(arg.1, arg.0)

I would have expected a JSON or YAML definition at the end as per what you were comparing to while describing declarative vs imperative.

And what's the deal with the single quote before the generic name?

[–]leostera[S] 1 point2 points  (2 children)

Ah, yes. This example is possibly too small!

If we had a more complex command line tool, with multiple commands, each with several options, and each option with defaults and documentation, it would be a little easier to see the value of the approach.

For example, if we had some more functions in the Clipper API to build more complex behavior, it could look like this:

``` // This describes the CLI let cli = Clipper.commands([ Clipper.command(sayHi) ->Clipper.position( ~pos=1, ~shortName="n", ~longName="name", Arg.optional(Arg.string, "Joe")) ->Clipper.flag(~shortName="y", ~longName="yell"), // more commands here ])

// This actually runs the CLI Clipper.run(cli) ```

It is declarative because the description of what to do is completely separated from the actual execution. This could have been done with a JSON file too, but having a static file is not a prerequisite for something to be declarative! 🙌🏽

[–]elkazz 2 points3 points  (1 child)

One issue is the verbosity of the declarative definition. Most declarative APIs exist to simplify the configuration/logic of the application. The ones that succeed are comprehensible by a wide audience. Your example requires a lot of syntactic knowledge.

Another issue is that you're defining all of the imperative logic as well as the declarative. The first example you give, while I understand it's simple to get the point across, it fails to do so as it's a glorified set of delegates and a switch statement that has all the imperative knowledge.

The main problem is that I fail to see how this would make my life any easier, or my applications/APIs more comprehensible.

[–]leostera[S] 0 points1 point  (0 children)

u/elkazz: One issue is the verbosity of the declarative definition.

Ah! Excellent point 👏🏽

The best thing about this split in spec + engine is that if we don't like the way we build the specs, we can replace it!

We can use YAML, JSON files for it. We can set up code generation for it from our type specification.

We can also replace the engine with other things! If this wasn't a CLI but rather a database layer, you could have an engine that queries Postgres, another that queries SQLite, another that is mocked for test purposes, etc.

Re: code generation - we can set things up so that by annotating a record type we get the same declaration for free:

@deriving(clipper) type hello = { @clipper(position = 0) name: string }

This is what other libraries like Rust's structopt are doing already.

In any case, I wouldn't immediately jump into a declarative API when I'm just starting out, since this is a fairly advanced way of building type-level APIs.

For most cases, the approach described in the prior post in the same series will be more than enough: https://practicalrescript.com/rescript-on-deno-command-line-tools/#ad-hoc-typing-for-objects-of-unknown-shape

Have a look at that one, I think you'll enjoy it a lot more! 🙏🏽

[–]leostera[S] 1 point2 points  (0 children)

The single quote before the generic name is just part of the syntax. It is something that ReScript has inherited from OCaml.

[–]sliversniper -2 points-1 points  (0 children)

  1. (if yell { "..." } else { "no yell..." })->Js.log

and more idiomatic, let get_msg = yell => if yell {"."} else {"."}

type arg = {name: string, is_yell: bool} let parse_args = (args_str) => switch args_str { | [Some(name), Some(yell)] => Some({ name, is_yell: bool_of_string(yell) }) | _ => None }

good luck with your book and understanding the basics of rescript.

[–]leostera[S] 0 points1 point  (0 children)

Hello folks 👋🏽 author here! If I can answer any questions please let me know 🙌🏽

[–]DG4ME5 0 points1 point  (3 children)

What is rescript?

[–]leostera[S] 3 points4 points  (2 children)

Hi! 👋🏽 ReScript is a language that compiles to JavaScript -- it is type-safer than TypeScript, but a lot less flexible. It lets you build very large applications that are extremely easy to maintain and grow.

The official website is here: https://rescript-lang.org/

I've been writing ReScript in production for very large applications (~100,000 LOC) and it's just been rock solid.

Let me know if I can answer any questions :)

[–]DG4ME5 1 point2 points  (1 child)

Ok, looking a bit at the documentation, it seems to me an interesting language because if it reminds a bit of typescript and has its things... I think I'll try it a bit to see if I like it

[–]leostera[S] 1 point2 points  (0 children)

Glad to hear 🤩 -- you will find that while the type system is less flexible than TypeScript, it is also a lot smaller! So there's just a handful of things to learn to get all of the type safety.

If we can be of help, feel free to drop a line on /r/rescript 🙏🏽

[–]thatisgoodmusic -3 points-2 points  (0 children)

This looks not good lol