bVNC Pro (Secure, open source VNC client) - https://f-droid.org/app/com.iiordanov.bVNC

H

@sjoelund I was thinking of how this could be solved in Modelica (or (undocumented) Mo script) but did not come to any result. Do you think it is possible at all by using operator overloading?

g()().

This is not valid syntax and not even a parse_transform can save you :(

When you say g('al') must return "gal".

Do you mean that the actual return value of function g is "gal" or do you mean that the string "gal" must be printed by the specified invocation of function g?

Cause I have something that does this:

def g(s=None,n=0): return 'G'+'o'*n+s if s else lambda s=None,n=n+1: g(s,n)

The Haskell one is super clever for a number of reasons!

1. Foremost, g() is not syntax for calling g with no arguments, it's syntax for calling g with a single argument: the empty tuple

2. There is no such thing as a polyvariadic (i.e. a function with "splat" arguments) function in Haskell! The type must indicate the exact set of arguments

3. Haskell is statically typed, so if you try to write a function which returns a function then the type would fix how many times you could apply an empty tuple. In other words, here's a simple function which returns g()()("al") --> "gooal"

   g :: () -> (() -> (String -> String))
   g = \() -> \() -> \string -> "goo" ++ string
   

   if it's not clear, there's no room for this function to suddenly accept a new tuple argument.

So, this seems pretty terrible. How does the solution work?

"Simple." We teach the compiler how to generate, on the fly, every possible function:

    g0(s) -- "g" ++ s
    g1()(s) -- "go" ++ s
    g2()()(s) -- "goo" ++ s
    g3()()()(s) -- "gooo" ++ s
    ...

then we name them all g. At compile time Haskell wanders around looking for (ambiguous) references to g, infers their type, and then uses that inferred type to determine which of the gN-series of functions is correct!

Then it inlines that gN function, typechecks it to prove that everything is sane, and goes on its merry way.

I said that Haskell demands we give exact types to all functions. So what's the type of g?

g :: (Goaly a, Stringy b) => b -> a

Here, Goaly and Stringy are defined in eatnumber1's solution. Roughly, they indicate polymorphism: b can be either () or a string indicating the two kinds of input types we're interested in and a is either a String (if we're demanding the result) or a "continuation" function of type (Goaly a, Stringy b) => b -> a again.

Together these cases ensure that we've got an inductive definition of the entire family of gN functions. We've actually defined something even larger, to be honest:

>>> g()"ooooo"()"al" :: String
"goooooooal"

We can even add more cases

instance Stringy Int where
  toString 0 = "o"
  toString n = show n
  (+++) x y = x ++ toString y

>>> default (Int)
>>> g()0()0()0()0()0()0"al" :: String
"gooooooooooooal"

Would be PHP solution g[][]['al'] counted as "close" or "incomplete"?

Shell is too generic. The examples in incomplete/shell are written for Bourne shells.
Since Z Shell is also listed, I think it makes sense to be more precise.

This is impossible in Rust because Rust cannot have functions that accept a variable number of arguments.

i want to do a string match for 'product' column in data set A with 'Description' column in dataset B and get the corresponding cost. If no match found I want something like 'NA' or 'No match' using R

The two data set look like this:

data set A:

and the second data set is:

data set B:

i want the output to look like the one below:

I have tried the grep and agrep but was not able to arrive at the desired output.

Any help from your end is Appreciated.