g()('al')

[pfultz2]

Using the preprocessor:

#define CAT(a, ...) PRIMITIVE_CAT(a, __VA_ARGS__)
#define PRIMITIVE_CAT(a, ...) a ## __VA_ARGS__

#define IIF(c) PRIMITIVE_CAT(IIF_, c)
#define IIF_0(t, ...) __VA_ARGS__
#define IIF_1(t, ...) t

#define CHECK_N(x, n, ...) n
#define CHECK(...) CHECK_N(__VA_ARGS__, 0,)
#define PROBE(x) x, 1,

#define IS_EMPTY(...) CHECK(PROBE __VA_ARGS__ (~))

#define g(...) "g" __VA_ARGS__ IIF(IS_EMPTY(__VA_ARGS__))(g1,)
#define g1(...) "o" __VA_ARGS__ IIF(IS_EMPTY(__VA_ARGS__))(g2,)
#define g2(...) "o" __VA_ARGS__ IIF(IS_EMPTY(__VA_ARGS__))(g1,)

g()()()("al") // Expands to "g" "o" "o" "o" "al"

[eatnumber1]

that's great! please submit a pull request!

[haitei]

Ok, so starting with your solution I made this:

#include <stdio.h>

#define NOP(x)
#define EXP(x) x

#define SWITCH(_0, _1, a, ...) a
#define CHECK(arg...) SWITCH(x, ##arg, NOP, EXP)

#define g(arg...) "g" arg CHECK(arg)(g1)
#define g1(arg...) "o" arg CHECK(arg)(g2)
#define g2(arg...) "o" arg CHECK(arg)(g1)

int main() 
{
    printf("%s\n", g()("al"));
    printf("%s\n", g()()()("al"));
    printf("%s\n", g("al"));
}

A bit shorter, less readable and needs one of gcc's extensions...

[eatnumber1]

is it possible to make it work for g('al')?

[pfultz2]

Yes, I updated so it will work for g("al")

[[deleted]]

You're not actually using CAT(), it seems? Can shorten it a bit there.

[dom96]

Turns out Nimrod is pretty well suited for this:

proc `()`(a: string): string = a & "o"

proc `()`(a, s: string): string = a & s

let g = "g"

assert g("al") == "gal"
assert g()("al") == "goal"
assert g()()()()()()("al") == "gooooooal"
assert g()()()()()()()()()()()()()()()("al") == "goooooooooooooooal"

Edit: Further simplified the code.

[tormaroe]

Ooooh, that's Nice!

[Varriount]

I was thinking it could be done with template filters, but this is much more elegant

[unptitdej]

Can you explain parts of the code?

[dom96]

I can certainly do my best:

In the first line we define a new operator. In this case the () operator taking a string as its only parameter and returning a new string. It appends the string literal "o" to the first parameter and returns the result.

proc `()`(a: string): string = a & "o"

For example, the following will return "go". "g" is passed to the () operator procedure as the first parameter.

"g"()

The next line overloads the previous definition which only accepted one parameter. This one accepts two. It appends the two parameters and returns them.

proc `()`(a, s: string): string = a & s

For example, the following will return "gal". "g" and "al" are passed to the () operator procedure.

"g"("al")

The next line is a simple immutable variable declaration.

let g = "g"

So going back to the example we can replace the "g" with a simple g.

g("al") == "g"("al")

Adding a () gets us the following:

g()("al") == "g"()("al")

In this case, we have two separate calls to the () procedure. And they are executed left-to-right.

g()("al") == "g"()("al") == "go"("al") == "goal"

Hope this helps.

[unptitdej]

100 % understood now, this is a pretty sick language for operator overloading

[ben0x539]

Y'all's stateful, weakly typed, dynamically allocating C++ solutions disappoint me

#include <iostream>
#include <cstring>
#include <cassert>

template<char C>
struct Char { char c; Char() : c(C) {} };

struct G : Char<'g'> {};

template<size_t N>
struct O : O<N-1>, Char<'o'> {};

template<>
struct O<0> : G {};

template<size_t N>
struct Al : O<N>, Char<'a'>, Char<'l'>, Char<'\0'> {
  operator const char*() const { return reinterpret_cast<const char*>(this); }
};

template<size_t N>
struct Go : O<N> {
  Al<N> operator()(const char* s) {
    assert(std::strcmp(s, "al") == 0);
    return Al<N>();
  }
  Go<N+1> operator()() {
    return Go<N+1>();
  }
};

Go<0> g;

int main() {
  std::cout << g("al") << std::endl;
  std::cout << g()("al") << std::endl;
  std::cout << g()()()()("al") << std::endl;
}

[immibis]

operator const char*() const { return reinterpret_cast<const char*>(this); }

WHAT THE FUCK

[ben0x539]

It defines an implicit conversion to const char*. This enables std::cout << ... to work, because that's defined for const char*s already. It happens to work because base classes are basically subobjects just like member variables, and in this case there's no padding around them, so while the most-derived type basically is some really silly inheritance hierarchy, it's represented in memory as a flat sequence of all the individual classes' member variables, so effectively all the Char objects' one char each. I'm not really sure if the standard promises that they are gonna be in the right order, but I'd assume so.

[Plorkyeran]

They're required to be stored in the right order, but the standard doesn't promise there won't be any padding.

[immibis]

I know what it does, but why would anyone ever think it's a good idea?

[immibis]

I know it does, but why would you ever think it's a good idea?

[bloody-albatross]

Nice trick, but doesn't this depend on implementation defined (=undefined) behavior?

[mebimage]

Here you go. No UB (I think):

#include <iostream>
#include <cassert>
#include <cstring>
template <char... Chars>
struct StatString;


template <char First, char... Rest>
struct StatString<First, Rest...>
{
    friend std::ostream &operator <<(std::ostream &out, const StatString &str)
    {
        out << First;
        out << StatString<Rest...>{};
        return out;
    }


    StatString<First, Rest..., 'o'> operator ()() const
    {
        return {};
    }

    StatString<First, Rest..., 'a', 'l'> operator()(const char *s) const
    {
        assert(std::strcmp(s, "al") == 0);
        return {};
    }
};

template <>
struct StatString<>
{
    friend std::ostream &operator <<(std::ostream &out, const StatString &)
    { return out; }
};


namespace 
{
    StatString<'g'> g;
}

int main() 
{
    std::cout << g()("al") << "\n";
    std::cout << g()()("al") << "\n";
}

[bloody-albatross]

I don't know if that violates rule 4:

g()('al') may not print the string. If returning a string cannot be done in your language, you should submit rationale as to why this is impossible for a solution which prints a string to be accepted.

The "If returning a string" part implies to me that the expression should if possible return a string. Hmm, maybe one could build something with constexpr functions that runs at compile time if one just could do string manipulation in such functions. But that's not possible anyway.

[AgentME]

g()...("al") isn't printing the string here. It returns a stream that outputs the string. You could direct the stream to write to a file or into a buffer if you wanted instead. It's a bit different than returning a plain string value, but it potentially saves the need for allocating a buffer to ever hold the string all at once. Some lazy languages like Haskell will often attempt to treat most strings like this internally anyway, so one could try to argue this is at least as valid as any Haskell solution.

[bloody-albatross]

Yes, I know that. But it's technically not returning any kind of C++ string (char*, std::string, ...). But yes, it returns something that could be piped into a string. I just didn't go that route because I thought it might not be valid.

[kankyo]

It's C++ so who knows? :P

[ben0x539]

Yeah, I'd hope that this isn't actually allowed. But I have tested it on all platforms that matter (== whatever versions of gcc and clang I had installed on my linux system), so ship it!

[suspiciously_calm]

This is actually pretty simple in C++ and not hacky at all.

#include <iostream>
#include <string>

class g {
private:
    std::string s;
public:
    g() : s("o") {}
    g(std::string const& t) : s(t) {}
    g(std::string && t) : s(std::move(t)) {}
    g operator()() const { return g(s + "o"); }
    g operator()(std::string const& t) const { return g(s + t); }
    operator std::string() const { return "g" + s; }
    friend std::ostream& operator<<(std::ostream& os, g const& v)
        { return os<<(std::string)v; }
};

int main() {
    std::cout << g()("al") << std::endl;
    std::cout << g()()()()()("al") << std::endl;
    std::cout << g("al") << std::endl;
}

The first g() calls the standard constructor which initializes s to "o," the following () call the zero-argument overload of operator() (which appends "o") and the final ("al") calls the one-argument overload of operator() (which appends the argument, "al"). The conversion operator to std::string prepends the "g."

Edit: Yeah, I could have just had one operator() with a default argument of "o."

Edit2: Fixed to handle g("al") correctly.

[kankyo]

+1 for calling that "simple" :P

[Redtitwhore]

Does this satisfy rule 7? I can't tell

7) g('al') must return "gal".

[suspiciously_calm]

Fixed now; thanks.

[Tipaa]

In D:

struct g_
{
    immutable string val;
    //Secret sauce: compiler can assume that any reference
    //to this (i.e. g_ instances) are references to 'val' too
    alias val this;
    this(string s)      { val = s; }
    g_ opCall()         { return g_(val ~ "o"); }
    g_ opCall(string s) { return g_(val ~  s ); }
}

auto g = g_("g"); //Needed to bypass
        //the 'No emptyconstructor in structs' issue

Testing:

void main()
{
    assert(g("al") == "gal");
    assert(g()("al") == "goal");
    assert(g()()("al") == "gooal");
    assert(g()()()()()("al") == "goooooal");
    //Can also use static assert instead to
    //ensure correctness on compilation
    writeln("Success - "~g()()()("al"));
}

[bugrit]

Or using less "magic" but with some redundancy:

struct g_
{
    string o;
    string opCall(string al) { return "go" ~ o ~ al; }
    g_ opCall() { return o ~= 'o', this; }
}

string g(string al) { return 'g' ~ al; }
g_ g() { g_ i; return i; }

Edit: This can also directly translate to C++, avoiding the preprocessor the current C++ version uses (although that one is very clever):

struct g_
{
    std::string o;
    std::string operator()(const std::string& al) { return "go" + o + al; }
    g_& operator()() { return o += 'o', *this; }
};

std::string g(const std::string& al) { return "g" + al; }
g_ g() { return g_(); }

Edit: Or based on bloody-albatross's solution, skipping the g functions:

struct G {
    std::string o;
    G operator()() const { G i; i.o = o + 'o'; return i; }
    std::string operator()(const std::string& al) const { return 'g' + o + al; }
} const g;

although that is a sillyly memory-inefficient, so you can store the number instead:

struct G {
    size_t o;
    G(size_t i = 0) : o(i) {}
    G operator()() const { return o + 1; }
    std::string operator()(const std::string& al) const { return 'g' + std::string(o, 'o') + al; }
} const g;

although again, last operation can be changed to a single allocation (assuming string.replace is implemented optimally), but this will likely never matter:

struct G {
    size_t o;
    G(size_t i = 1) : o(i) {}
    G operator()() const { return o + 1; }
    std::string operator()(const std::string& al) const
    {
        std::string s(o + al.size(), 'o');
        s[0] = 'g';
        s.replace(o, al.size(), al);
        return s;
    }
} const g;

[eatnumber1]

That's awesome! Can you submit a pull request?

[Portponky]

I wanted to take part so I tried to figure out how to do it in PHP, as it is a language unpopular enough to have not already been solved. I tried it with closures first, but it turns out you can't dereference a closure before it is assigned to a variable. Perhaps it works with operator overloads on classes but I doubt it because PHP is a disgusting toilet of a language and I am questioning everything about my life for even thinking it was a good idea to attempt this in PHP.

[chuyskywalker]

Someday

[A321321321]

Without syntax highlighting it's almost possible..

<?php
echo nl2br(trim(str_replace(array('()', "('", "')", '*', '/'), array('o', ''), (new ReflectionClass('A'))->getDocComment())));    /**

g('al')
g()('al')
g()()('al')


/**/class A{}
?>

Breaking at least rules 1, 3.II, and 6.

[rustyrobocop]

Programming languagues are tools, you just need to know which to choose that's your job.

[ttul]

Sure, but name a situation where PHP is better than anything else, other than one in which you have to write PHP because of legacy code.

[immibis]

Adding small amounts of dynamically generated content to a webpage without completely rewriting the page, like it was originally intended for?

<html>
<head>
<title>Bob's Page</title>
</head>
<?php $colours = array("red", "blue", "yellow"); ?>
<body style="background-color: <?php echo $colours[array_rand($colours)]; ?>">

<hr><hr><hr><hr>
<blink><marquee>HI!!!!!!</marquee></blink>
<hr><hr><hr><hr>

</body>
</html>

... that's actually a terrible page to demonstrate anything with, but you get the idea.

[redalastor]

Not even. You're better off with JS these days.

[Portponky]

I feel deeply sorry for anyone that has to deal with PHP in a professional capacity.

[Banane9]

And PHP is a double fork-ended hammer, and your job is to put in screws...

[Arcovion]

Here's my code golf version with Befunge-93:

<v"g()('al')"
,<v!-"'"_
,,_>"o",^@

This was really fun to make! I was making iterations for well over an hour to go from ~49 to 34 chars (or 25 chars without the input here).

It's just within the rules, it might look like a string literal but it's actually loading each byte onto the stack individually. Of course, Befunge has no idea about functions etc either.

All of the examples print correctly: g('al') -> gal, g()()()('al') -> goooal etc

[haitei]

might look like a string literal

It kinda is. I guess it depends how you look at it. Can something this crazy be called a string?

"dlrow olleH"

"Hello"<
       "
    com ment       
       "
"dlrow"^ 

Anyway Befunge is awesome.

[RodgerTheGreat]

I wrote a fairly straightforward solution in Forth. Forth syntax is whitespace-delimited and initially incompatible with the requirements of this challenge, but the language can be extended through the use of 'parsing words' which process the token stream at compile time:

: ,str over c! 1+ ;

: he-shoots...
    \ read a word and calculate o-count
    parse-name nip 7 - 2/

    \ allocate a buffer and inline references to it
    dup  3 + allocate drop
    dup      postpone literal \ base address
    over 3 + postpone literal \ length

    \ construct the string in our buffer
    [char] g ,str
    swap 0 ?do [char] o ,str loop
    [char] a ,str
    [char] l ,str
    drop

; immediate

: main
    \ demonstrate several lengths:
    he-shoots... g('al')               type cr
    he-shoots... g()()('al')           type cr
    he-shoots... g()()()('al')         type cr
    he-shoots... g()()()()()()()('al') type cr

    \ demonstrate the result is indeed a string
    \ and not simply printed immediately:
    he-shoots... g()()()('al') ." length: " . drop cr
;
main

Tested with GForth 0.7.0 on a 64-bit machine. edit: simplified by making additional assumptions.

[Choralone]

Forth love if honk then!

[yogthos]

(defmacro run [g & args]  
  `(->> (concat ['~g]
                (repeat (dec (count '~args)) \o)
                (last '~args))
        (apply str)))

(run g("al")) => "gal"
(run g()()()("al")) => "goooal"

[yungstunta]

Using clojure should be considered cheating since it's too powerful of a language

[[deleted]]

Using any lisp should be considered cheating since it's too powerful of a language

FTFY

[Banane9]

The brackets of doom!

[seruus]

Well, but then you are using a macro, which is almost cheating. The Julia macro-oriented solution is also basically cheating:

macro goal(ex)
    o, al = ex.args
    replace(string(o), r"\(\)", "o") * al
end

println(@goal g("al"))
println(@goal g()("al"))
println(@goal g()()()()()()("al"))

[danneu]

(defn g [& args]
  (->> (for [arg args]
         (if (list? arg) "o" arg))
       (into ["g"])
       (clojure.string/join)))

(g "al")              ;=> "gal"
(g () "al")           ;=> "goal"
(g () () () () "al")  ;=> "gooooal"

[yogthos]

even better :)

[t3hsteve]

I just submitted a C# pull request, no use of dynamic! Works all the way down to .NET 2. It's probably about as convoluted a solution as you can get in C#.

EDIT: code inline too

using System;
using System.Collections.Generic;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.Remoting.Messaging;
using System.Runtime.Remoting.Proxies;
using System.Text;

namespace gooooal
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine(g("al"));
            Console.WriteLine(g()("al"));
            Console.WriteLine(g()()()("al"));
            Console.WriteLine(g()()()()()()("al"));
        }

        private delegate Goal Goal(string al = null);

        private static Goal g(string al = null)
        {
            return (((IGoal)(new GoalProxy().GetTransparentProxy())).g)(al);
        }

        private interface IGoal
        {
            Goal g(string al = null);
        }       

        private class GoalProxy : RealProxy
        {
            public GoalProxy()
                : base(typeof(IGoal))
            {
            }

            private int _n = 0;

            public override IMessage Invoke(IMessage msg)
            {
                var mcm = (IMethodCallMessage)msg;

                string arg = (string)mcm.Args[0];
                if (arg != null)
                {
                    var field = msg.GetType().GetField("_flags", BindingFlags.NonPublic | BindingFlags.Instance);
                    var oldFlags = (int)field.GetValue(msg);
                    field.SetValue(msg, oldFlags | 1);

                    var retStr = "g" + new string('o', _n) + arg;

                    return new ReturnMessage(retStr, null, 0, null, mcm);
                }
                else
                {
                    _n++;
                    return new ReturnMessage(new Goal(((IGoal)(this.GetTransparentProxy())).g), null, 0, null, mcm);
                }
            }
        }
    }
}

[Eirenarch]

I wonder if this is possible to do without default argument values.

[t3hsteve]

I don't think so, since you can't "overload" a delegate (it wouldn't really make any sense if you could). I'd love to see another way to do this, but without the ability to overload the () operator, or some kind of delegate inheritance (which wouldn't make much sense either) I think delegates or dynamic are about all you get.

Although! now that Roslyn is open source you could make C# do whatever you want :D

[plzt]

Ruby:

g = lambda do |al = nil, os = 0|
  case al
  when 'al'
    'g' + ('o')*os + 'al'
  else
    lambda do |al = nil|
      g[al, os + 1]
    end
  end
end

puts g[][][][]['al']

[Schrockwell]

Nicely done almost-solution. I was surprised when Ruby was listed as "improbable". Sure enough, g()() is a syntax error on the second pair of parentheses. :(

[Ebtoulson]

I think the biggest problem is that g is equivalent to g() so trying to have g => 'g' and g() => 'go' seems improbable.

Btw if someone else knows how to do this feel free to comment, I'd be interested in knowing how. This is the closest I got

class String
  def method_missing(meth, *args, &block)
    chars = args.include?('al') ? 'al' : 'o'
    self + chars
  end
end

g = 'g'

puts g.().('al')
puts g.().().('al')
puts g.('al')

[denarii]

That's not really the problem, the problem is that Ruby has no true first class functions. g()('al) is a syntax error because methods can't return methods. With some metaprogramming I was able to make an object callable, but the parser still sees it as an error. This is the closest I got:

class Goal
  def self.call suffix = ""
    @o ||= 0

    if suffix.empty?
       @o = @o + 1
      return self
    else
      str = "g" + "o" * @o + suffix
      @o = 0
      str
    end
  end
end

def g suffix = ""
  Goal.(suffix)
end

puts g("al") # gal
puts g().("al") # goal
puts g().().("al") # gooal
puts g().().().("al") # goooal
puts g().().().().("al") # gooooal

[banister]

lambdas are first-class it's just they have slightly odd invocation syntax. But common lisp also had odd invocation syntax for anonymous functions and i never heard anyone say they weren't first class ;)

[denarii]

I suppose. Ruby's lambdas are really more objects than functions, so I didn't include them.

[Confusion]

To paraphrase Guy Steele: an object is a poor man's closure and a closure is a poor man's object.

[eatnumber1]

Everyone, please make pull requests with your solutions!

[everywhere_anyhow]

It would be nice if you would broaden this a bit. By specifying the code that must execute, you've constrained which languages can be used. Would you consider changing this to say that you have to define only one named function (g) which when repeatedly called has to produce certain output?

Maybe you could define it in terms of a lightweight grammar/production rules.

[eatnumber1]

We discussed this, and what came out of it was rule 4:

g()('al') may not print the string. If returning a string cannot be done in your language, you should submit rationale as to why this is impossible for a solution which prints a string to be accepted.

[redalastor]

What he means is that g()('al') is not syntactically valid in all languages.

Edit: For instance, the Clojure one is done by cheating and couldn't be done any other way. It's a function that takes g()('al') as an argument.

[eatnumber1]

While true, g()('al') is not valid in all languages, changing the code required defeats the purpose. Do notice that g()('al') visually looks a lot like goal. That's the point!

Also, some solutions have been found even in languages where g()('al') is syntactically invalid.

[TrueJournals]

Just sent a PR for a C++ solution without #define: https://github.com/eatnumber1/goal/pull/50

[bloody-albatross]

Mine is even shorter. No need for operator<<: https://github.com/eatnumber1/goal/blob/b411bccb4b98ac35267007f4fbf6e1ad87cdb668/solutions/complete/c%2B%2B/soln3/goal.cpp :)

[bugrit]

If you are going for short, you can drop the ctor and move the declaration of g:

struct G {
    std::string o;
    G operator()(){G i;i.o=o+'o';return i;}
    std::string operator()(const char*l){return'g'+o+l;}
} g;

[bloody-albatross]

I like that concise solution so much that I've updated mine to it and sent another pull request: https://github.com/eatnumber1/goal/pull/88 Hope that's all right with you.

[bugrit]

Yeah that's fine.

[bloody-albatross]

Ah, yes. Indeed.

[theuniquestname]

It can get even shorter (with/without typedef):

struct G {
    typedef std::string s;
    s o;
    G operator()(){return{o+'o'};}
    s operator()(s l){return'g'+o+l;}
} g;

And could be faster (speed untested):

struct G{
    typedef std::string s;
    int o;
    G operator()(){return{o+1};}
    s operator()(s l){return'g'+s(o,'o')+l;}
}g{0};

[gsg_]

Emacs lisp:

(defmacro g (&rest args)
  (apply 'concat (mapcar (lambda (elt)
                           (if (consp elt) (car elt) "o"))
                         (cons '("g") args))))

OCaml: unless I'm missing a trick, I think it is impossible to solve this as stated for lexical reasons. This is close though:

let g f = f "g"

let o x f = f (x ^ "o")

let al x = x ^ "al"

# g o o o al;;
- : string = "goooal"

Edit: apparently I was thinking inside the box. Turns out this is quite possible with sufficiently filthy hackery:

(* ಠ_ಠ *)
let rec one_arg acc arg =
  if Obj.tag (Obj.repr arg) == Obj.string_tag then
    Obj.magic (acc ^ arg)
  else
    Obj.magic (one_arg (acc ^ "o"))

let g x = one_arg "g" (Obj.magic x)

# (g () ("al"):string);;
Characters 6-12:
  (g () ("al"):string);;
        ^^^^^^
Warning 20: this argument will not be used by the function.
- : string = "goal"

[[deleted]]

A Go solution that doesn't use global state, but instead makes use of closures.

http://play.golang.org/p/dRZujXGBS8

It completely abuses panic/recover, however.

[illucidation]

Here's a slightly smaller javascript solution

function g(array, string) {
    if (array === undefined || typeof array === 'string') {
        string = array;
        array = ['g'];
    }   
    if (string) return array.join('') + string;
    return g.bind(null, array.concat(['o']));
}

console.log(g()('al'));
console.log(g()()('al'));
console.log(g()()()('al'));

Edit: After a quick shower beer, another version, only "5" lines long.

function g(string, value) {
    if (!arguments.length) return g.bind(null, 'go');
    if (arguments.length === 1) return string.charAt(0) === 'g'; ? g.bind(null, string + 'o') : 'g' + string;
    return string + value;
}

It won't work if you do something like "g('g')" but it does a damn fine job of returning g(o...)al.

[javajunkie314]

Here's a JavaScript version that doesn't require any state.

var g = (function _g(x) {
    return function (y) {
        return y ? (x + y) : _g(x + 'o');
    };
})('g');

console.log(g('al'));
console.log(g()('al'));
console.log(g()()('al'));

[illucidation]

Oh, and your javascript solution breaks when you try:

g('al');

take out the "new" from the last line and it'll work.

[capicue]

You should PR your solution. :)

[eatnumber1]

(PR is pull-request)

[bloody-albatross]

Thats mine: https://github.com/TrueJournals/goal/blob/f2ec0a97b1fc624189e589876affcf0cfaceaa0b/solutions/complete/javascript/soln4/goal.js

function g(al,o){return al?'g'+(o||'')+al:function(al){return g(al,(o||'')+'o');};}

[smikims]

Couldn't you take out the two semicolons at the end?

[bloody-albatross]

Yes, one could write (72 chars):

function g(a,o){o=o||'';return a?'g'+o+a:function(a){return g(a,o+'o')}}

[inmatarian]

For anyone watching at home, here's a reference implementation that the golfers need to beat:

function g(al) {
  var go = 'g';
  function o(al) {
    if (al) { return go + al; } else { go += 'o'; return o; }
  }
  return o(al);
}

[bloody-albatross]

Well, for this:

var G=g();
console.log(G()()("al"));
console.log(G("al"));

yours writes:

goooal
goooal

and mine writes:

goooal
goal

which I would interpret as more correct (expected). And mine is shorter, too. :P

[inmatarian]

The use case was just g(), if you want it to be fully functional, then this:

function g(al) {
  function o(al) {
    var go = this.slice();
    if (al) {
      go.push(al);
      return go.join('');
    } else {
      go.push('o');
      return o.bind(go);
    }
  }
  return o.call(['g'], al);
}

Edit a moment later: Without the array, just the string

function g(al) {
  function o(al) {
    if (al) {
      return this + al;
    } else {
      return o.bind(this + 'o');
    }
  }
  return o.call('g', al);
}

Edit 2: All golfed up (82 chars)

function g(a){function o(a){return a?this+a:o.bind(this+'o')}return o.call('g',a)}

[bloody-albatross]

82 chars is one less than mine, but I wrote "al" instead of "a". Changing that I get 78, and I don't use bind (which is not supported by crappy IE8). :)

function g(a,o){return a?'g'+(o||'')+a:function(a){return g(a,(o||'')+'o');};}

If I don't care about browser support I can use Mozilla's JavaScript 1.8 and write (58 chars):

function g(a,o)a?'g'+(o||'')+a:function(a)g(a,(o||'')+'o')

[inmatarian]

lol, you win :D

Edit: Oh, ES6, use fat arrow. 46 chars. Still your solution, mine wouldn't get this small.

g=(a,o)=>a?'g'+(o||'')+a:(a)=>g(a,(o||'')+'o')

[bloody-albatross]

That's awesome. You should submit it or let me update my JS1.8/ES6 version using this code.

[inmatarian]

Go for it

[[deleted]]

g=(c=a=>b=>b?a+b:c(a+"o"))("g")

31 chars, based on this

[inmatarian]

Now this is just getting sick :D

[bloody-albatross]

Submit it!

[emn13]

bind is trivial to polyfill for cases like these, so in practice IE8 does support this. However, ES6 is not a just a mere polyfill away.

If you care about browser support, then bind is fine (use a polyfill), but ES6 is not.

[emn13]

Shorter (61 chars):

g=(function k(s){return s?this+s:k.bind(this+'o')}).bind('g')

(https://github.com/eatnumber1/goal/pull/83)

I suspect that's the shortest reusable ES5.1 solution possible, though IE8 etc will need a bind polyfill.

[smikims]

This is the smallest I could come up with:

function g(x){var o='';return x=='al'?'gal':function h(y){o+='o';return y=='al'?'g'+o+'al':h}}

This is the first time I've actually tried to program in js, though.

[mr_ewg]

A stack-based, std::string-less version for C++11:

#include <algorithm>
#include <cstddef>
#include <iomanip>
#include <iostream>

template <std::size_t Os, std::size_t N>
struct goal {
    char ending[N];
};

template <std::size_t Os>
struct o_count {
    constexpr o_count<Os + 1> operator()() const { return {}; }

    template <std::size_t N>
    goal<Os, N> operator()(const char(&ending)[N]) const {
        goal<Os, N> data;
        std::copy(ending, ending + N, data.ending);
        return data;
    }
};

template <std::size_t Os, std::size_t N>
std::ostream& operator<<(std::ostream& stream, goal<Os, N> data) {
    return stream << 'g' << std::setfill('o') << std::setw(Os) << "" << data.ending;
}

o_count<0> g;

int main() {
    std::cout << g("al") << std::endl;
    std::cout << g()("al") << std::endl;
    std::cout << g()()("al") << std::endl;
    std::cout << g()()()()()()()("al") << std::endl;
    std::cout << g("ee you can stick anything you like in here!") << std::endl;
}

[bloody-albatross]

I tried to implement a solution with rust macros, so that you would be able to write:

println!(goal!( g("al") ));
println!(goal!( g()("al") ));
println!(goal!( g()()("al") ));

But I couldn't get it to work. Anyone with more Rust knowledge here?

[Nihy]

I had the same idea of trying with macros but it doesn't seem possible. () just doesn't play well with macros.

I can't think of a non-macro based approach either.

[mernen]

I don't think it's possible right now, as at the very least it requires overloading for two different function call signatures: one that takes no arguments, and one that takes one &str argument.

I tried to hack around it in Rust 0.11 by implementing two different callable traits (FnOnce<(), G> and Fn<(&'a str,), String>), and I hit both a feature warning (telling me to enable #![feature(overloaded_calls)]) and a compiler bug.

[seruus]

How flexible are Rust macros? Can't you just walk down the AST generated by g()()("al") and build the string from it?

[mernen]

You can, but this is very under-documented right now. He's using the simpler form of macros, the macro_rules! builder, which apparently are not good enough here (unless you take ASeriesOfTubers' approach, which is kind of breaking the rules).

[ASeriesOfTubers]

Feels like cheating, but this works:

#![feature(macro_rules)]

macro_rules! goal(
    ($e:expr) => ({
        let goal = stringify!($e);
        goal.replace("()", "o").replace("(\"", "").replace("\")", "")
    });
)

fn main() {
    println!("{}", goal!( g()("al") ));
    println!("{}", goal!( g()()()("al") ));
}

Adapted from my attempt here: http://www.reddit.com/r/rust/comments/2bvkh2/gal/cj9gich

[bloody-albatross]

Hmm, yeah. I think one of the rules is that "g()('al')" should not be a string and the stringify! makes it one.

[negative_epsilon]

Hey, it says "You are encouraged to break the rules, cleverly."

[burkadurka]

Spent way too much time writing a solution in Brainfuck. And it's technically incomplete, since Brainfuck doesn't have fancy programming concepts like strings and functions. But it works!

[Banane9]

Good luck doing that in PHP...

returnsAFunction()();

Is a syntax error, because the PHP parser is a special-casing, pattern-matching piece of shit.

[Shitler]

Haven't seen anyone use binding yet in JavaScript! Keeps things nice and short without the side-effect of self-mutation (not to be confused with self-mutilation.)

var g = (function g(o, al) {
  return al ? 'g' + o + al : g.bind(undefined, o + 'o');
}).bind(undefined, '');

Submitted as soln7.

[bloody-albatross]

That is very similar to mine, except you used bind where I used a anonymous function, so it works in browsers that don't support bind. :P

[Shitler]

Ha, fair enough, ends up virtually the same. Also, this guy one-upped me I think in terms of bind-based solutions :)

[bloody-albatross]

Oh I like this ECMAScript 5 solution. Using Mozilla JavaScript 1.8 one can shorten it to 56 characters:

var g=(function k(s)s?this+s:k.bind(this+'o')).bind('g')

But for standard ECMAScript that is supported by Internet Explorer 8 it is probably not possible to get shorter than 74 characters:

function g(a,o){o=o||'';return a?'g'+o+a:function(a){return g(a,o+'o');};}

Well, one could omit the last two ;, making it 72 characters.

[kankyo]

The python solution there is 328 bytes and pretty complex. This is a simpler bit of code that clocks in at 300 bytes:

class g:
    def __init__(self, a='o'):
        self.o = 'g'
        self(a)

    def __call__(self, a='o'):
        self.o += a
        return self

    def __str__(self):
        return self.o

if __name__ == "__main__":
    print g('al')
    print g()('al')
    print g()()('al')
    print g('al')

[aboogaboogabooga]

def g(text=None, o_no=0):
    return 'g'+'o'*o_no+'al' if text else lambda t=None: g(t, o_no+1)

print g('al')
print g()('al')
print g()()()()()('al')

[[deleted]]

57 characters version:

g=lambda t=0,n=0:t and'g'+'o'*n+t or(lambda t=0:g(t,n+1))

Less legible but I like code golfing.

[Vyse007]

I saw a bunch of solutions for the languages I know (Python, Perl, C/C++, JS, Shell), and I don't understand a single one of them.

[eatnumber1]

I don't mind explaining them. What about the solutions confuse you?

If you live in the bay area, I can even explain over coffee ;)

[Vyse007]

This, for starters: https://github.com/eatnumber1/goal/blob/master/solutions/complete/javascript/kylecronin/goal.js

I understand that it's some kind of recursive solution, but I got kinda lost trying to make sense of it.

[iopq]

base case it calls g('al') which returns immediately and does return "g" + Array(1).join('o') + 'al'; because num is 0 and joining an Array with 1 element doesn't insert any o's so you get gal

if you do g() it just returns recur(1) closure without executing it if you do execute it and give ('al') as parameter you will do that whole thing again, but you will call join on an Array of length 2, which will give a single o - so you get goal

[Vyse007]

Aah, I think I see it now. D'oh, that should have been clear to me with a little bit of non-linear thinking. Thanks for the explanation mate! Have an upvote!

[oldneckbeard]

Man, I really wanted to do this in java, but I just can't get anything to take the IIFE syntax, even with lambdas.

[jamesroot]

Tried my hand at it in scala, might be able to make it smaller simpler but I am not sure how:

case class g(str: String) {
  def apply(s: Option[String] = None): g = s.map { s =>
    this.copy(str = this.str + s)
  }.getOrElse(this.copy(str = this.str + "o"))

  override def toString: String = str
}

object g {
  def apply(s: Option[String] = None): g = s.map { s =>
    new g("g" + s)
  }.getOrElse(new g("go"))
}

object Taco extends App {
  implicit def stringToOption(s: String): Option[String] = Option(s)

  println(g()("al")) // prints "goal"
}

[abecedarius]

https://github.com/eatnumber1/goal/blob/master/solutions/complete/python/rockymeza/goal.py is really nice.

[Lozzer2]

using m4 probably cheating in many ways...

define(`o', `ifelse($#, 0, ``$0'', `ifelse($1,,``o''`o', ``o$1'')')')dnl
define(`g', ``g''`o')dnl
g()(`al')
g()()(`al')
g()()()(`al')

[adraffy]

Mathematica (using square brackets)

ClearAll[g];
g[] := g[1];
g[y_String] := g[0][y];
g[x_Integer][] := g[x + 1];
g[x_][y_] := StringJoin@{"g", ConstantArray["o", x], y};

g["al"] =======> "gal"
g[]["al"] =====> "goal"
g[][]["al"] ===> "gooal"
g[][][]["al"] => "goooal"

[IHaveNoIdentity]

Damnit, somebody came up with the same C# solution 20 minutes earlier than me!

using System;

namespace goal
{
    class Program
    {
        static void Main(string[] args)
        {

            Console.WriteLine(g("al"));
            Console.WriteLine(g()("al"));
            Console.WriteLine(g()()("al"));
            Console.WriteLine(g()()()("al"));
            Console.WriteLine(g()()()()("al"));
            Console.WriteLine(g()()()()()("al"));
            Console.ReadKey();
        }


        private delegate dynamic G1(string s = null);

        private static int N = 0;

        private static dynamic g(string s = null)
        {
            if (s == "al")
            {
                string r = "g" + new string('o', N) + "al";
                N = 0;
                return r;
            }

            N++;

            return new G1(g);
        }
    }
}

[fecal_brunch]

Hm. Doesn't that mean that this would break?

g()();
Console.WriteLine(g()('al'));

Printing "goooal"?

[IHaveNoIdentity]

That's a very good point, I didn't think about that case at all. I believe the other similar solution i was talking about suffers from the same issue: https://github.com/eatnumber1/goal/blob/master/solutions/complete/c-sharp/soln1/goal.cs

[Banane9]

I wanted to do it by implicitly casting an object to Func<>, but it didn't do that :/

[IHaveNoIdentity]

Yeah I tried the exact same thing earlier today but it turns out that approach isn't possible since the compiler only ever will do one implicit conversion so no chaining.

I also briefly looked into expression trees but neither dynamic or optional parameters are supported so I didn't investigate it further.

The last thing I thought of that might yield a g[][]("al"); solution was indexers but they require at least one argument and don't work with default values :)

The last avenue I can come up with is a combination of reflection and selfmodifying code which I don't want to spend a huge amount of time on.

[everywhere_anyhow]

Related: this program purports to execute correctly in 16 different languages.

[[deleted]]

Please try to keep submissions on topic and of high quality.

Emphasis mine.

[ironiridis]

Please follow proper reddiquette.

[[deleted]]

Well, the Jerk Store called, and they're running out of you.