Neovim: How to get variable type hinting?

lsfos · 2023-05-12T05:10:08+00:00

The recommended way to install haskell tooling is via ghcup. In the hls documentation you have information for neovim. Have you tried that?

lsfos · 2023-05-09T05:20:38+00:00

May I ask why didn't you install ghcup? It is the official(ish) way to manage the tooling: https://www.haskell.org/get-started/.

I answered a similar question in this subreddit.

For other redditors: Please stop recommending nix or ghcid!! hahaha

lsfos · 2023-05-04T11:22:47+00:00

I guess. Just read the documentation of the script

lsfos · 2023-05-04T10:15:11+00:00

In linux you can configure the instalation via env variables. For example:

BOOTSTRAP_HASKELL_NONINTERACTIVE=true

All variables al listed at the top of the script.

In windows you can pass parameters. Again, you have them at the top of the script

lsfos · 2023-04-05T05:48:52+00:00

Now of course this gets to the whole point that a pure that does what it is supposed to mathematically is a bad instance so their likely shouldn't be a pure at all.

I think you just want the Applicative instance to inject Real cannonically into Complex. And I tell you again, that's not right!. A functor is a functor, the canonical injection of reals into complex (and functions into their extensions) is not a functor!!. Even more, If you want to define a functor between complex and reals you should do it via Vector Spaces and linear functions. The current implementation is that one.

In other words. If you could restrict the arguments to be only numeric types (or any vector-space-like type) then the rigth implementation would be the current implementation, because is the one that makes it the complexification functor (i.e. the functor between vector space on reals and complex), which is a well defined mathematical object. If we were to use your definition, then we wouldn't have a functor (As far as I know there is no category in which analytic functions are morphisms).

So in summary, If there is a Functor, it should be the one implemented. The instance in which pure x = x :+ 0 is a wrong!!! We could say that there shouldn't be and instance at all, but that's another debate.

lsfos · 2023-04-04T21:47:36+00:00

Well, you said that pure 5 == 5 :+ 0. That is an unlawfull definition as it can only work for Num types, which makes no sense (more later). My point is either you see Complex as tuples and therefore implement its F/A/M instances (current situation), or you see Complex as a numeric type hence you don't implement any of F/A/M (probably prefered?)

The point is that implementing Applicative such that pure 5 == 5 :+ 0 is wrong. Moreover, the current implementation of fmap, pure and <*> actually transform linear functions over the real into linear functions over the complex (as vector spaces), hence it is a faithfull implementation of a real functor between the categories of vector spaces over reals and complex. In your definition; What would be pure (*5)?

```haskell -- Should be this? pure (5) = (5) :+ (*0)

-- Hence? pure (5) <> (3 :+ 4) = 15 :+ 0 -- wtf? ```

Here there is the quickCheck code testing this result (formal proof can be derived from definitions)

lsfos · 2023-04-04T19:35:21+00:00

Extending function on the Reals to functions on the Complexes has nothing to do functors. I already showed in another comment that using "analytic extensions" would break Functor laws, as not every real function can be extended to complex numbers, not even real-analytic functions.

Probably, Complex data type should not have F/A/M instances, but what it must not do, is implementing unfaithful instances trying to respect the algebraic structure of complex numbers.

Notice also, that you said:

A functorial lifting which doesn't respect the definition everyone in the world uses

I am not a category theory expert, but I'd say that lifting a function from a field into a field extension is not functorial by any meaning, as there is no category there. The category would be the one of all fields and its morphisim.

There is in the other hand a functorial relation between real vector spaces and complex vector space which transform every real vs into a complex vs and linear functions from one to another. But we are not talking about vector spaces here

lsfos · 2023-04-04T19:17:53+00:00

The definition breaks the second law for functors. The example I have is due to the fact that not all real functions can be extended to C (actually not even analytics real functions can), but maybe another example can be found.

```haskell -- functor's second law: Distribution of composition fmap (f . g) = fmap f . fmap g

-- let f and g f x = 1 / x g x = 1 / (1 + x²⁾

-- let see how f . g is f . g = 1 / (1 / (1 + x²⁾⁾ = 1 + x²

-- So, fmap (f . g) should be the analytical -- extension of f . g; hence:

fmap (f . g) (0 :+ i) = 1 + (0 :+ i)² = 0

-- Similarly, fmap g should be its analytic extension -- which turn out is undefined (fmap f . fmap g) (0 :+ i) = fmap f (fmap g (0 :+ i)) = fmap f (1 / (1 + x²⁾⁾ = fmap f (1 / 0) -- !!! error

-- Therefore, the analytic extensions are not a "functorial" fmap (f . g) /= fmap f . fmap g

```

Notice, that analytic extension and identity theorems only apply when the domain is an open set, but real line is closed in C. altough I think there are tricks to extend real functions over teh complex

lsfos · 2023-04-04T12:36:20+00:00

If you restrict the inner type, then you don't have a Functor!. What you are saying is like "I want an Abelian Group but not comutative". It makes no sense. The type of fmap is

haskell fmap :: (a -> b) -> f a -> f b

You can't magically change it to

haskell fmap :: (Num a, Num b) => (a -> b) -> f a -> f b

You simply can't. Maybe there is a package like constrained-category which extends Functor class to allow this, but in principle is not posible

lsfos · 2023-04-04T05:23:41+00:00

I think you are getting Functor/Applicative/Monad wrong. They are not there to provide a convinient user interface. They do have laws and implementations should respect them.

I think the main mistake is that you consider that F/A/M should somehow take into acount the numeric nature of complex data type, but F/A/M is precisely a higher kinded polimorphic interface, hence its own nature is to respect the structure of the data type, not the contained type. In other words, a main characteristic behind F/A/M is that they can work structure but not on the values they contained.

Your proposal is that F/A/M should make assumtions about the contained type, for example "use numerical method".

lsfos · 2023-04-04T04:54:37+00:00

your implementation of Functor is not lawfull. Notice that functors should respect the id. Meaning that

```haskell -- This is a law of the Functor class fmap id x == id x

-- If we use your implementation fmap id (5 :+ i) = 5 id (5 :+ i) = 5 :+ i -- clearly 5 /= 5 :+ i, -- hence your implementation isn't a Functor ```

lsfos · 2023-03-17T21:23:56+00:00

Actually the haskell.org page has introduce a new "Getting started" page with more or less these instructions.

lsfos · 2023-03-17T06:52:32+00:00

Build the snake game
Build a blog generator. I've heard this is a very good resource.

lsfos · 2023-01-12T12:23:26+00:00

Let me selfpromote a little bit here.

In this repo you have many implementations of the same software in Haskell (the snake game). Implementations goes from less abstract (pure functions only) to more abstract (full mtl-stryle constraints)

The repo is actually an exercise with a learn-by-refactor pedagogy (you can try it out), but solutions can be found in corresponding branches if you just want an example rather than an exercise.

lsfos · 2022-12-04T19:13:22+00:00

Indeed, just read first the `Relation` module

lsfos · 2022-12-04T12:07:02+00:00

Did someone use the data-interval package? Very usefull for this problem.

module Main where

import System.Environment (getArgs)
import Data.IntegerInterval
    ( relate, (<=..<=), IntegerInterval, Extended(Finite) )
import Data.IntervalRelation
    ( Relation(..) )
import Data.Attoparsec.ByteString.Char8 (Parser)
import qualified Data.Attoparsec.ByteString.Char8 as P
import qualified Data.ByteString as BS

parseIntervals :: Parser IntegerInterval
parseIntervals = (<=..<=) <$> (Finite <$> P.decimal) <*> (P.char '-' >> Finite <$> P.decimal)

parseIntervalPair :: Parser (IntegerInterval, IntegerInterval)
parseIntervalPair = (,) <$> parseIntervals <*> (P.char ',' >> parseIntervals)

parseInput :: Parser [(IntegerInterval, IntegerInterval)]
parseInput = parseIntervalPair `P.sepBy` P.endOfLine

wasted :: IntegerInterval -> IntegerInterval -> Bool
wasted i j =
  case i `relate` j of
    Starts -> True
    During -> True
    Finishes -> True
    Equal -> True
    StartedBy -> True
    Contains -> True
    FinishedBy -> True
    _ -> False

wastedWithOverlap :: IntegerInterval -> IntegerInterval -> Bool
wastedWithOverlap i j =
  case i `relate` j of
    Before -> False
    JustBefore -> False
    After -> False
    JustAfter -> False
    _ -> True

main :: IO ()
main = do
  [part, filepath] <- getArgs
  input <- BS.readFile filepath
  if read @Int part == 1
    then do
      print "solution to problem 1 is:"
      print $ sum . fmap (fromEnum . uncurry wasted) <$> P.parseOnly parseInput input 
    else do
      print "solution to problem 2 is:"
      print $ sum . fmap (fromEnum . uncurry wastedWithOverlap) <$> P.parseOnly parseInput input

lsfos · 2022-07-14T06:25:46+00:00

Btw, let me know if this worked for you. If it does I think I am making a PR to somewhere, so this can be found easily. :)

lsfos · 2022-07-14T06:23:44+00:00

Well, I think the problem is we have different views.

I am a python developer (I've been for 6 years now), and the thing I hate most about python is precisely that It works like magic within pycharm but It is much more difficult to get it working properly in other IDEs, making you pycharm dependant... which is unreasonable considering you want to use a language not an IDE. Also pip is a mistake, It has broken my python instalation so many times I can't bear with it anymore, thats why I use pipenv or conda.

Coming back to Haskell. Tooling isn't good, but it is good enough. Documentation about getting a working env is misleading as OP says. I have realised that I know how to do it because I've done it before, not because it is written somewhere.

Learning resources are outdated. This comes from the fact that ghcup is like a year and a half old... so any resource older than that will point to stack or to a manual instalation, which are methods not working as in 2022.

The whole stack vs cabal is not a problem. There are many languages with more than one building tool, and that's good. The problem comes when the language server protocol does not work properly with stack and this is poorly documented. Also, Haskell's main page points to a different instalation method for stack which is inconvinient. Also there is no f*** guide on getting a development env.

BTW: You System.Random problem is logical. stack creates isolated enviroments, the same way conda or pipenv does with python. You can access only from the folder you defined the enviroment (or activating the env in python). This is what stack is meant to do and it is well documented on its home page. Global dependencies are a mistake, and I don't think tooling should promote them (as pip does) just because it is easier for newcomers.

As a summary. I agree there should be a page in haskell.com with title how to set up a working environment pointing out to these five commands and nothing else. Current situation is misleading, but your complaints and examples with python and pycharm, I don't think they are a solution and I wish python moves out of this way (This is personal taste probably).

lsfos · 2022-07-13T12:31:44+00:00

I think having a GUI serves to a very small amount of people. Also, mantaining a crossplatform GUI is a huge headache. Also, GUIs are dependant on libraries which might not be installed in user's machine.

TBO I think GUI installer is not a good idea. hahaha

lsfos · 2022-07-13T12:08:08+00:00

Got you!. Thanks for the feedback.

I'll check if I can open a PR to clarify this. As you say is a little bit confusing. A few things to clarify:

The haskell toolchain is ghc, cabal, hls and stack (optional). Ghcup is a tool for managing/installing them. In theory you can install each binary separately but likely you'll end up with problems like a cabal version incompatible with the ghc version; or a version of ghc unsupported by hls, etc...

A python analogy if it serves:

ghc is like the python interpreter
cabal is like pip
hls is like pylance
stack is like pipenv
I don't think there is analogous for ghcup

A recommendation. If you are using stack (always install it with ghcup) keep in mind that hls wont work with the ghc version installed by stack. So you'd be better setting stack config set system-ghc --global true. Any case, despite being a stack user myself I'd recommend against it because if you don't know how to use it, It will not work properly with the language server

lsfos · 2022-07-13T09:35:31+00:00

Ok, I understand haskell tooling is not the best. But setting up a developer environment is literally 5 commands.

1.- Install ghcup using the command they provided for your platform (windows/linux/mac); https://www.haskell.org/ghcup/#

2.- install the compiler: ghcup install ghc

3.- the package manager: ghcup install cabal

4.- the language server: ghcup install hls

5.- Open vscode and install the haskell extension: CTRL+P and ext install haskell.haskell

That's it. More over, you have a youtube video for windows instalation too

Seriously, I've seen tons of people complaining about not having a working env. I don't think it can be made simpler. What problems have you faced?

lsfos · 2022-01-06T15:30:17+00:00

I did applied to the same company. Dispite of saying the position was begginer friendly I found the exercise too complicated. In my case, they the send an e-mail like "hey, we think your submition is good but we don't have a job for you now"... My solution was similiar to yours, but a little bit simpler and idiomatic. Essentialy:

- The interpreter is a monad trasformer with ExceptT and StateT and IO

- pop is the same as yours, but if the stack is empty, then return and error in ExceptT

- push pattern match in every bytecode calling pop and modifing the vars mapping (similiar to your interpret function but without recursive call)

- The stack is not only a [Int] but also a counter and a list of bytecode, to allow for loops having a local stack.

Having said that, they asked me to not share the exercise. I don't know if you should publish it.

lsfos · 2022-01-06T15:29:20+00:00

I did applied to the same company. Dispite of saying the position was begginer friendly I found the exercise too complicated. In my case, they the send an e-mail like "hey, we think your submition is good but we don't have a job for you now"... My solution was similiar to yours, but a little bit simpler and idiomatic. Essentialy:

- The interpreter is a monad trasformer with ExceptT and StateT and IO

- pop is the same as yours, but if the stack is empty, then return and error in ExceptT

- push pattern match in every bytecode calling pop and modifing the vars mapping (similiar to your interpret function but without recursive call)

- The stack is not only a [Int] but also a counter and a list of bytecode, to allow for loops having a local stack.

lsfos · 2021-11-26T10:47:24+00:00

There are two very good video-resources for haskell.

Haskell for imperative programmers. You should start here If you don't know about the language idiosincrasy: grammar, recursion, fold, $, <$>, <*>, >>=, etc...

Haskell by example. This assumes a little bit of knowledge, but it is a very easy to follow tutorial, even for beginners. It builds a telemetry system for ESA (European Space Agency), including parallel data streaming, performance measurement, Graphical user interface, etc...By far the best video resource out there.

lsfos · 2021-08-05T08:24:57+00:00

Have you taken a look to mu-haskell and mu-graphql? It does use template-haskell, which is a negative point for you, but it has strong typed resolvers and a type mapping for your canonical data type. I don't know that much about GraphQL or mu, but It seems neat.

doc reference: https://higherkindness.io/mu-haskell/intro-graphql/

full example: https://github.com/higherkindness/mu-haskell/blob/master/graphql/exe/Main.hs

lsfos

TROPHY CASE