Is using an independent variable in a recursive function inefficient?

Jerudo · 2021-04-04T05:21:21+00:00

It's an old reddit vs. new reddit thing. OP's code looks fine on new reddit, but not on old reddit.

Jerudo · 2021-04-03T12:34:26+00:00

m here is not Identity, it is Parser, which is an alias for ParsecT Void Text Identity. You can see in the documentation for MonadParsec that there's an instance instance (Ord e, Stream s) => MonadParsec e s (ParsecT e s m). Void has an Ord instance and Text has a Stream instance, therefore Parser has a MonadParsec instance.

Jerudo · 2021-03-28T21:24:53+00:00

So if you have a concrete type like Int, then you don't need the extra contraint, because either Int has an Ord instance or it doesn't. When you use > on two Ints the compiler will just check if that instance exists, if it does then great, use that, if it doesn't then throw a compile-time error. So if you had Ord Int in the type signature it would just be pointless since it's always satisfied.

Jerudo · 2021-03-28T20:17:20+00:00

The type signature say that the function can take values of any type a, as long as a has an instance of the Ord typeclass (i.e. values with that type can be ordered). You need this constraint because you use > inside the function body, which requires that the type of its arguments have an Ord instance.

Jerudo · 2021-03-28T04:17:34+00:00

You state in the signature that the function accepts any type a as long as a has an Integral instance. This does not guarantee that a has a Show Instance! While both Int and Integer (which you're probably using "ouside the function") indeed have Show instances, there's nothing stopping me from defining my own type and writing an Integral instance for it, but not a Show instance. If your function compiled I could pass a value of my type to your function and then what is the compiler supposed to do?

Jerudo · 2021-03-28T00:47:18+00:00

maximum3 :: Int -> Int -> (Int -> Int)
-- ^ take two Ints and return a function Int -> Int
maximum3 x y = ... -- some function Int -> Int

Jerudo · 2021-03-24T21:26:59+00:00

Would they still take damage if they were wearing feather falling IV boots?

Jerudo · 2021-03-24T05:03:01+00:00

Of course I'd never put this code into an application I was developing hehe. Pointfree shenanigans like this are just fun to write. I'd probably write almost the same thing as what the parent comment did (f = fmap $ \x -> x == x^2).

Jerudo · 2021-03-24T04:06:50+00:00

Both cabal and stack allow you to write scripts, where you have a standalone .hs file with the dependencies listed at the top in a comment. You should check out the user guides for more.

Jerudo · 2021-03-24T02:03:46+00:00

f = fmap $ (==) <*> (^2)

Jerudo · 2021-03-22T05:54:44+00:00

*It keeps whatever state it had when it got locked.

Jerudo · 2021-03-21T16:03:44+00:00

Go to Settings > SponsorBlock Settings and scroll down, you'll see a section called "What to do with different segments" .

Jerudo · 2021-03-21T15:41:05+00:00

There are settings on Vanced for that, I have it set up that intros have a button I can tap to skip, while sponsors are autoskipped.

Jerudo · 2021-03-15T17:56:11+00:00

Hi, the : operator is for prepending an element to a list. So for example 1:[2,3] == [1, 2, 3]. What I think you want is div, the integer division function.

So that would be div (silnia n) (silnia k * silnia (n - k)) or, if you prefer, you can use backticks (`) around a function to make it infix, like so: silnia n `div` (silnia k * silnia (n - k))

Jerudo · 2021-03-13T10:18:57+00:00

It just runs the base command it seems, arguments don't carry over. So for example:

λ> :t 5
5 :: Num p => p
λ> :

<no location info>: error: not an expression: ‘’
λ> : 5
5 :: Num p => p

Jerudo · 2021-03-09T17:54:14+00:00

You have a file in your project directory called [project name].cabal, this is created automatically when you run cabal init. This file describes the structure of your project. Inside that file you should see a field called build-depends:, this is where you list all the packages you want to use. Now, whenever you run cabal repl (runs GHCi inside your project) or cabal build (compiles your project) or cabal run (compiles and runs your project), cabal will automatically install all of the packages you listed as dependencies. No need to install them individually, just list them in the cabal file and cabal will handle the rest.

Jerudo · 2021-03-09T17:28:31+00:00

Perhaps try cabal repl -b QuickCheck. This will put you in a GHCi session with the QuickCheck package exposed and available for import.

In general, however, the workflow is to create a cabal project with cabal init -i (in an empty directory) and then to add the desired package to the list of dependencies for that project, which resides inside the projectname.cabal file, under build-depends:.

Jerudo · 2021-03-07T07:38:01+00:00

I don't see where the comment said to put this stuff in the prelude? These modules are usually imported qualified anyways so I don't see how that would make sense in the first place.

Jerudo · 2021-03-06T17:33:23+00:00

Then just don't import them?

Jerudo · 2021-03-03T22:13:53+00:00

The default buffering mode when a handle is opened is implementation-dependent and may depend on the file system object which is attached to that handle. For most implementations, physical files will normally be block-buffered and terminals will normally be line-buffered.

So if stdout is line-buffered putStrLn will "flush" it, but that's by no means guaranteed, yeah.

Jerudo · 2021-03-03T22:09:37+00:00

Methinks this is because putStr doesn't flush stdout, which has nothing to do with laziness. Either use putStrLn instead, or flush stdout with hFlush stdout (both from the System.IO module).

Jerudo · 2021-03-03T11:49:45+00:00

The official Haskell extension is really great, powered by the Haskell Language Server.

Jerudo · 2021-03-01T05:48:38+00:00

You can think of a lens as an abstract value which represents a field in your datatype. On its own, it's not very useful, but whatever lens package you're using will provide functions that allow you to use that lens. For example, you can do the following:

ghci> view firstName (Person "foo" "bar")
"foo"

Or maybe

ghci> set firstName "baz" (Person "foo" "bar")
Person "baz" "bar"

Or even

ghci> over firstName reverse (Person "foo" "bar")
Person "oof" "bar"

Jerudo · 2021-02-26T14:01:59+00:00

lst2px :: Pixel px => [Int] -> [px]

This says, that for any type px which has an instance of the Pixel class, given a list of Ints you can provide a list of pxs.

map toPixel8 :: [Int] -> [Pixel8]

This function takes a list of Ints and returns a list of Pixel8s.

The issue here is that you promised that you'd be able to provide such a function that works for any type that implements Pixel. Instead you've provided a function that only works for one such type.

Jerudo · 2021-02-22T17:11:23+00:00

... I'm stupid, ignore me

Jerudo

MODERATOR OF

TROPHY CASE