{"action":"created","comment":{"url":"https://api.github.com/repos/JuliaLang/julia/pulls/comments/51430424","id":51430424,"diff_hunk":"@@ -6,234 +6,386 @@\n  Scope of Variables\n ********************\n \n-The *scope* of a variable is the region of code within which a variable\n-is visible. Variable scoping helps avoid variable naming conflicts. The\n-concept is intuitive: two functions can both have arguments called ``x``\n-without the two ``x``'s referring to the same thing. Similarly there are\n-many other cases where different blocks of code can use the same name\n-without referring to the same thing. The rules for when the same\n-variable name does or doesn't refer to the same thing are called scope\n-rules; this section spells them out in detail.\n+The *scope* of a variable is the region of code within which a\n+variable is visible. Variable scoping helps avoid variable naming\n+conflicts. The concept is intuitive: two functions can both have\n+arguments called ``x`` without the two ``x``'s referring to the same\n+thing. Similarly there are many other cases where different blocks of\n+code can use the same name without referring to the same thing. The\n+rules for when the same variable name does or doesn't refer to the\n+same thing are called scope rules; this section spells them out in\n+detail.\n \n Certain constructs in the language introduce *scope blocks*, which are\n regions of code that are eligible to be the scope of some set of\n-variables. The scope of a variable cannot be an arbitrary set of source\n-lines; instead, it will always line up with one of these blocks.\n-The constructs introducing such blocks are:\n-\n--  ``function`` bodies (:ref:`either syntax <man-functions>`)\n--  ``while`` loops\n--  ``for`` loops\n--  ``try`` blocks\n--  ``catch`` blocks\n--  ``finally`` blocks\n--  ``let`` blocks\n--  ``type`` blocks.\n-\n-Notably missing from this list are\n-:ref:`begin blocks <man-compound-expressions>` and :ref:`if blocks <man-conditional-evaluation>`, which do\n-*not* introduce new scope blocks.\n-\n-Certain constructs introduce new variables into the current innermost\n-scope. When a variable is introduced into a scope, it is also inherited\n-by all inner scopes unless one of those inner scopes explicitly\n-overrides it.\n+variables. The scope of a variable cannot be an arbitrary set of\n+source lines; instead, it will always line up with one of these\n+blocks.  There are two main types of scopes in Julia, *global scope*\n+and *local scope*, the latter can be nested.  The constructs\n+introducing scope blocks are:\n+\n+.. _man-scope-table:\n+\n++--------------------------------+----------------------------------------------------------------------------------+\n+| Scope name                     | block/construct introducing this kind of scope                                   |\n++================================+==================================================================================+\n+| :ref:`global <man-global>`     | | module, baremodule, at interactive prompt (REPL)                               |\n++--------------------------------+------------------------------+---------------------------------------------------+\n+| :ref:`local <man-local-scope>` | :ref:`soft <man-soft-scope>` | | for, while, list-comprehensions,                |\n+|                                |                              |   try-catch-finally, let                          |\n+|                                +------------------------------+---------------------------------------------------+\n+|                                | :ref:`hard <man-hard-scope>` | | functions (either syntax, anonymous & do-blocks)|\n+|                                |                              | | type, immutable, macro                          |\n++--------------------------------+------------------------------+---------------------------------------------------+\n+\n+Notably missing from this table are :ref:`begin blocks\n+<man-compound-expressions>` and :ref:`if blocks\n+<man-conditional-evaluation>`, which do *not* introduce new scope\n+blocks.  All three types of scopes follow somewhat different rules\n+which will be explained below as well as some extra rules for\n+certain blocks.\n \n Julia uses `lexical scoping <http://en.wikipedia.org/wiki/Scope_%28computer_science%29#Lexical_scoping_vs._dynamic_scoping>`_,\n meaning that a function's scope does not inherit from its caller's\n scope, but from the scope in which the function was defined.\n-For example, in the following code the ``x`` inside ``foo`` is found\n-in the global scope (and if no global variable ``x`` existed, an\n-undefined variable error would be raised)::\n+For example, in the following code the ``x`` inside ``foo`` is refers\n+to the ``x`` in the global scope of its module ``Bar``::\n \n-    function foo()\n-      x\n+    module Bar\n+    x = 1\n+    foo() = x\n     end\n \n-    function bar()\n-      x = 1\n-      foo()\n-    end\n+and not a ``x`` in the scope where ``foo`` is used::\n \n-    x = 2\n+    julia> import Bar\n \n-    julia> bar()\n-    2\n+    julia> x = -1;\n \n-If ``foo`` is instead defined inside ``bar``, then it accesses\n-the local ``x`` present in that function::\n+    julia> Bar.foo()\n+    1\n \n-    function bar()\n-      function foo()\n-        x\n-      end\n-      x = 1\n-      foo()\n+Thus *lexical scope* means that the scope of variables can be inferred\n+from the source code alone.\n+\n+.. _man-global:\n+\n+Global Scope\n+------------\n+\n+*Each module introduces a new global scope*, separate from the global\n+scope of all other modules; there is no all-encompassing global scope.\n+Modules can introduce variables of other modules into their scope\n+through the :ref:`using or import <man-modules>` statements or through\n+qualified access using the dot-notation, i.e. each module is a\n+so-called *namespace*.  Note that variable bindings can only be\n+changed within their global scope and not from an outside module. ::\n+\n+    module A\n+    a = 1 # a global in A's scope\n     end\n \n-    x = 2\n+    module B\n+    # b = a # would error as B's global scope is separate from A's\n+        module C\n+        c = 2\n+        end\n+    b = C.c # can access the namespace of a nested global scope\n+            # through a qualified access\n+    import A # makes module A available\n+    d = A.a\n+    # A.a = 2 # would error with: \"ERROR: type Module has no field a\"\n+    end\n \n-    julia> bar()\n-    1\n+Note that the interactive prompt (aka REPL) is in the global scope of\n+the module ``Main``.\n \n-The constructs that introduce new variables into the current scope\n-are as follows:\n-\n--  A declaration ``local x`` or ``const x`` introduces a new local variable.\n--  A declaration ``global x`` makes ``x`` in the current scope and inner\n-   scopes refer to the global variable of that name.\n--  A function's arguments are introduced as new local variables into the\n-   function's body scope.\n--  An assignment ``x = y`` introduces a new local variable ``x`` only if\n-   ``x`` is neither declared global nor introduced as local\n-   by any enclosing scope before *or after* the current line of code.\n-\n-In the following example, there is only one ``x`` assigned both inside\n-and outside the ``for`` loop::\n-\n-    function foo(n)\n-      x = 0\n-      for i = 1:n\n-        x = x + 1\n-      end\n-      x\n+.. _man-local-scope:\n+\n+Local Scope\n+-----------\n+\n+A new local scope is introduced by most code-blocks, see above\n+:ref:`table <man-scope-table>` for a complete list.  A local scope\n+*usually* inherits all the variables from its parent scope, both for\n+reading and writing.  There are two subtypes of local scopes, hard and\n+soft, with slightly different rules concerning what variables are\n+inherited.  Unlike global scopes, local scopes are not namespaces,\n+thus variables in an inner scope cannot be retrieved from the parent\n+scope through some sort of qualified access.\n+\n+The following rules and examples pertain to both hard and soft local\n+scopes.  A newly introduced variable in a local scope does not\n+back-propagate to its parent scope.  For example, here the ``z`` is not\n+introduced into the top-level scope::\n+\n+    for i=1:10\n+        z = i\n     end\n \n-    julia> foo(10)\n-    10\n+    julia> z\n+    ERROR: UndefVarError: z not defined\n+\n+(Note, in this and all following examples it is assumed that their\n+top-level is a global scope with a clean workspace, for instance a\n+newly started REPL.)\n \n-In the next example, the loop has a separate ``x`` and the function\n-always returns zero::\n+Inside a local scope a variable can be forced to be a local variable\n+using the ``local`` keyword::\n \n-    function foo(n)\n-      x = 0\n-      for i = 1:n\n+    x = 0\n+    for i=1:10\n         local x\n-        x = i\n-      end\n-      x\n+        x = i + 1\n     end\n \n-    julia> foo(10)\n+    julia> x\n     0\n \n-In this example, an ``x`` exists only inside the loop, and the function\n-encounters an undefined variable error on its last line (unless there is\n-a global variable ``x``)::\n+Inside a local scope a new global variable can be defined using the\n+keyword ``global``::\n \n-    function foo(n)\n-      for i = 1:n\n-        x = i\n-      end\n-      x\n+    for i=1:10\n+        global z\n+        z = i\n     end\n \n-    julia> foo(10)\n-    in foo: x not defined\n-\n-A variable that is not assigned to or otherwise introduced locally\n-defaults to global, so this function would return the value of the\n-global ``x`` if there were such a variable, or produce an error if no such\n-global existed. As a consequence, the only way to assign to a global\n-variable inside a non-top-level scope is to explicitly declare the\n-variable as global within some scope, since otherwise the assignment\n-would introduce a new local rather than assigning to the global. This\n-rule works out well in practice, since the vast majority of variables\n-assigned inside functions are intended to be local variables, and using\n-global variables should be the exception rather than the rule,\n-and assigning new values to them even more so.\n-\n-One last example shows that an outer assignment introducing ``x`` need\n-not come before an inner usage::\n-\n-    function foo(n)\n-      f = y -> n + x + y\n-      x = 1\n-      f(2)\n+    julia> z\n+    10\n+\n+..\n+   However, there is no keyword to introduce a new local variable into a\n+   parent local scope.\n+\n+The location of both the ``local`` and ``global`` keywords within the\n+scope block is irrelevant.  The following is equivalent to the last\n+example (although stylistically worse)::\n+\n+    for i=1:10\n+        z = i\n+        global z\n     end\n \n-    julia> foo(10)\n-    13\n+    julia> z\n+    10\n \n-This behavior may seem slightly odd for a normal variable, but allows\n-for named functions — which are just normal variables holding function\n-objects — to be used before they are defined. This allows functions to\n-be defined in whatever order is intuitive and convenient, rather than\n-forcing bottom up ordering or requiring forward declarations, both of\n-which one typically sees in C programs. As an example, here is an\n-inefficient, mutually recursive way to test if positive integers are\n-even or odd::\n+Multiple global or local definitions can be on one line and can also\n+be paired with assignments::\n \n-    even(n) = n == 0 ? true  :  odd(n-1)\n-    odd(n)  = n == 0 ? false : even(n-1)\n+    for i=1:10\n+        global x=i, y, z\n+        local a=4, b , c=1\n+    end\n \n-    julia> even(3)\n-    false\n \n-    julia> odd(3)\n-    true\n+.. _man-soft-scope:\n \n-Julia provides built-in, efficient functions to test for oddness and evenness\n-called :func:`iseven` and :func:`isodd` so the above definitions should only be\n-taken as examples.\n+Soft Local Scope\n+^^^^^^^^^^^^^^^^\n \n-Since functions can be used before they are defined, as long as they are\n-defined by the time they are actually called, no syntax for forward\n-declarations is necessary, and definitions can be ordered arbitrarily.\n+  In a soft local scope, all variables are inherited from its parent\n+  scope unless a variable is specifically marked with the keyword\n+  ``local``.\n \n-At the interactive prompt, variable scope works the same way as anywhere\n-else. The prompt behaves as if there is scope block wrapped around\n-everything you type, except that this scope block is identified with the\n-global scope. This is especially evident in the case of assignments:\n+Soft local scopes are introduced by for-loops, while-loops,\n+list-comprehensions, try-catch-finally-blocks, and let-blocks.  There\n+are some extra rules for :ref:`let-blocks <man-let-blocks>` and for\n+:ref:`for-loops and list-comprehensions <man-for-loops-scope>`.\n \n-.. doctest::\n+In the following example the ``x`` and ``y`` refer always to the same\n+variables as the soft local scope inherits both read and write\n+variables::\n \n-    julia> for i = 1:1; y = 10; end\n+    x,y = 0, 1\n+    for i = 1:10\n+        x = i + y + 1\n+    end\n \n-    julia> y\n-    ERROR: UndefVarError: y not defined\n+    julia> x\n+    11\n \n-    julia> y = 0\n-    0\n+Within soft scopes, the `global` keyword is never necessary, although\n+allowed.  The only case when it would change the semantics is\n+(currently) a syntax error::\n \n-    julia> for i = 1:1; y = 10; end\n+    let\n+        local x = 2\n+        let\n+            global x = 3\n+        end\n+    end\n \n-    julia> y\n-    10\n+    # ERROR: syntax: `global x`: x is local variable in the enclosing scope\n \n-In the former case, ``y`` only exists inside of the ``for`` loop. In the\n-latter case, an outer ``y`` has been introduced and so is inherited\n-within the loop. Due to the special identification of the prompt's scope\n-block with the global scope, it is not necessary to declare ``global y``\n-inside the loop. However, in code not entered into the interactive\n-prompt this declaration would be necessary in order to modify a global\n-variable.\n+.. _man-hard-scope:\n \n-Multiple variables can be declared global using the following syntax::\n+Hard Local Scope\n+^^^^^^^^^^^^^^^^\n \n+Hard local scopes are introduced by function definitions (in all their\n+forms), type & immutable-blocks and macro-definitions.\n+\n+   In a hard local scope, all variables are inherited from its parent\n+   scope unless:\n+\n+   - an assignment would result in a modified *global* variable, or\n+   - a variable is specifically marked with the keyword ``local``.\n+\n+Thus global variables are only inherited for reading but not for\n+writing::\n+\n+    x,y = 1,2\n     function foo()\n-        global x=1, y=\"bar\", z=3\n+        x = 2 # assignment introduces a new local\n+        return x + y # y refers to the global\n     end\n \n     julia> foo()\n-    3\n+    4\n \n     julia> x\n     1\n \n-    julia> y\n-    \"bar\"\n+An explicit ``global`` is needed to assign to a global variable::\n \n-    julia> z\n-    3\n+    x = 1\n+    function foo()\n+        global x = 2\n+    end\n+    foo()\n+\n+    julia> x\n+    2\n+\n+Note that *nested functions* can behave differently to functions\n+defined in the global scope as they can modify their parent scope's\n+*local* variables::\n+\n+    x,y = 1,2\n+    function foo()\n+        x = 2 # introduces a new local\n+        function bar()\n+            x = 10 # modifies the parent's x\n+            return x+y # y is global\n+        end\n+        return bar() + x # 12 + 10 (x is modified in call of bar())\n+    end\n+\n+    julia> foo()\n+    22  # (x,y unchanged)\n+\n+The distinction between inheriting global and local variables for\n+assignment can lead to some slight differences between functions\n+defined in local vs. global scopes.  Consider the modification of the\n+last example by moving ``bar`` to the global scope::\n+\n+    x,y = 1,2\n+    function bar()\n+        x = 10 # local\n+        return x+y\n+    end\n+    function foo()\n+        x = 2 # local\n+        return bar() + x # 12 + 2 (x is not modified)\n+    end\n+\n+    julia> foo()\n+    14 # as x is not modified anymore.\n+       # (x,y unchanged)\n+\n+Note that above subtlety does not pertain to type and macro\n+definitions as they can only appear at the global scope.\n+There are special scoping rules concerning the evaluation of default\n+and keyword function arguments which are described in the\n+:ref:`Function section <man-evaluation-scope-default-values>`.\n+\n+\n+An assignment introducing a variable used inside a function, type or\n+macro definition need not come before its inner usage:\n+\n+.. doctest::\n+\n+    julia> f = y -> x + y\n+    (anonymous function)\n+\n+    julia> f(3)\n+    ERROR: UndefVarError: x not defined\n+     in anonymous at none:1\n+\n+    julia> x = 1\n+    1\n+\n+    julia> f(3)\n+    4\n+\n+This behavior may seem slightly odd for a normal variable, but allows\n+for named functions — which are just normal variables holding function\n+objects — to be used before they are defined. This allows functions to\n+be defined in whatever order is intuitive and convenient, rather than\n+forcing bottom up ordering or requiring forward declarations, as long\n+as they are defined by the time they are actually called.  As an\n+example, here is an inefficient, mutually recursive way to test if\n+positive integers are even or odd::\n+\n+    even(n) = n == 0 ? true  :  odd(n-1)\n+    odd(n)  = n == 0 ? false : even(n-1)\n+\n+    julia> even(3)\n+    false\n+\n+    julia> odd(3)\n+    true\n+\n+Julia provides built-in, efficient functions to test for oddness and evenness\n+called :func:`iseven` and :func:`isodd` so the above definitions should only be\n+taken as examples.\n+\n+Hard vs. Soft Local Scope\n+^^^^^^^^^^^^^^^^^^^^^^^^^\n+\n+Blocks which introduce a soft local scope, such as loops, are\n+generally used to manipulate the variables in their parent scope.\n+Thus their default is to fully access all variables in their parent\n+scope.\n+\n+Conversely, the code inside blocks which introduce a hard local scope\n+(function, type and macro definitions) can be executed at any place in\n+a program.  Remotely changing the state of global variables in other\n+modules should be done with care and thus this is an opt-in feature","path":"doc/manual/variables-and-scoping.rst","position":512,"original_position":512,"commit_id":"abdfc24ac1a7acd67b474a1848758589d4613065","original_commit_id":"abdfc24ac1a7acd67b474a1848758589d4613065","user":{"login":"Sisyphuss","id":11466838,"avatar_url":"https://avatars.githubusercontent.com/u/11466838?v=3","gravatar_id":"","url":"https://api.github.com/users/Sisyphuss","html_url":"https://github.com/Sisyphuss","followers_url":"https://api.github.com/users/Sisyphuss/followers","following_url":"https://api.github.com/users/Sisyphuss/following{/other_user}","gists_url":"https://api.github.com/users/Sisyphuss/gists{/gist_id}","starred_url":"https://api.github.com/users/Sisyphuss/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/Sisyphuss/subscriptions","organizations_url":"https://api.github.com/users/Sisyphuss/orgs","repos_url":"https://api.github.com/users/Sisyphuss/repos","events_url":"https://api.github.com/users/Sisyphuss/events{/privacy}","received_events_url":"https://api.github.com/users/Sisyphuss/received_events","type":"User","site_admin":false},"body":"@mauro3 You are right. Module is like C++'s static class.","created_at":"2016-02-01T15:22:58Z","updated_at":"2016-02-01T15:22:58Z","html_url":"https://github.com/JuliaLang/julia/pull/12146#discussion_r51430424","pull_request_url":"https://api.github.com/repos/JuliaLang/julia/pulls/12146","_links":{"self":{"href":"https://api.github.com/repos/JuliaLang/julia/pulls/comments/51430424"},"html":{"href":"https://github.com/JuliaLang/julia/pull/12146#discussion_r51430424"},"pull_request":{"href":"https://api.github.com/repos/JuliaLang/julia/pulls/12146"}}},"pull_request":{"url":"https://api.github.com/repos/JuliaLang/julia/pulls/12146","id":39953495,"html_url":"https://github.com/JuliaLang/julia/pull/12146","diff_url":"https://github.com/JuliaLang/julia/pull/12146.diff","patch_url":"https://github.com/JuliaLang/julia/pull/12146.patch","issue_url":"https://api.github.com/repos/JuliaLang/julia/issues/12146","number":12146,"state":"open","locked":false,"title":"RFC: overhaul of \"Scope\" manual section","user":{"login":"mauro3","id":4098145,"avatar_url":"https://avatars.githubusercontent.com/u/4098145?v=3","gravatar_id":"","url":"https://api.github.com/users/mauro3","html_url":"https://github.com/mauro3","followers_url":"https://api.github.com/users/mauro3/followers","following_url":"https://api.github.com/users/mauro3/following{/other_user}","gists_url":"https://api.github.com/users/mauro3/gists{/gist_id}","starred_url":"https://api.github.com/users/mauro3/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/mauro3/subscriptions","organizations_url":"https://api.github.com/users/mauro3/orgs","repos_url":"https://api.github.com/users/mauro3/repos","events_url":"https://api.github.com/users/mauro3/events{/privacy}","received_events_url":"https://api.github.com/users/mauro3/received_events","type":"User","site_admin":false},"body":"Trying to fix issues #9469 and #9955, this turned into quite a substantial re-write of the \"Scope\" section of the manual.  I hope this is ok, please give feedback.  I do think that documenting global scope is addressed (#9469), as is the difference between soft and hard local scope (#9955), and the whole section maybe a bit more logically structured now.  A semi rendered version is [here](https://github.com/mauro3/julia/blob/m3/scope-doc/doc/manual/variables-and-scoping.rst).\r\n\r\nQuestion: is the [statement](https://github.com/mauro3/julia/blame/41911d96d86397168ade1f39914a8d7ed1653558/doc/manual/variables-and-scoping.rst#L203) about `global` never having any effect in soft local scopes correct?\r\n\r\nI'm not 100% happy with a few things but I ran out of time & steam (and expertise) to address them.  If you got quick fixes then let me know, otherwise they might be left for another day.  \"Issues\" left:\r\n\r\n- description of `let` could use some love.  In particular it is not quite clear what the difference is between introducing variables in its head vs. body.\r\n- macros could probably do with an example and a link to the somewhat related topic of hygiene\r\n- section on \"Constants\" seems a bit out of place.  But where to move it?\r\n- running the doctests I got lots of errors from everywhere.  Is that expected because on my path is Julia-0.3?  Or are they indeed broken?\r\n- some description/link for scope in parallel programs (edit: added)\r\n\r\nCc'ing people from the issues and some of the original authors: @elextr , @uvtc, @JeffBezanson, @Sisyphuss, @nolta\r\n\r\n(edited)","created_at":"2015-07-14T19:36:30Z","updated_at":"2016-02-01T15:22:58Z","closed_at":null,"merged_at":null,"merge_commit_sha":"758f97f2f3cfb4bccc2dd5b24c8b88f78725b1f7","assignee":{"login":"JeffBezanson","id":744556,"avatar_url":"https://avatars.githubusercontent.com/u/744556?v=3","gravatar_id":"","url":"https://api.github.com/users/JeffBezanson","html_url":"https://github.com/JeffBezanson","followers_url":"https://api.github.com/users/JeffBezanson/followers","following_url":"https://api.github.com/users/JeffBezanson/following{/other_user}","gists_url":"https://api.github.com/users/JeffBezanson/gists{/gist_id}","starred_url":"https://api.github.com/users/JeffBezanson/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/JeffBezanson/subscriptions","organizations_url":"https://api.github.com/users/JeffBezanson/orgs","repos_url":"https://api.github.com/users/JeffBezanson/repos","events_url":"https://api.github.com/users/JeffBezanson/events{/privacy}","received_events_url":"https://api.github.com/users/JeffBezanson/received_events","type":"User","site_admin":false},"milestone":null,"commits_url":"https://api.github.com/repos/JuliaLang/julia/pulls/12146/commits","review_comments_url":"https://api.github.com/repos/JuliaLang/julia/pulls/12146/comments","review_comment_url":"https://api.github.com/repos/JuliaLang/julia/pulls/comments{/number}","comments_url":"https://api.github.com/repos/JuliaLang/julia/issues/12146/comments","statuses_url":"https://api.github.com/repos/JuliaLang/julia/statuses/abdfc24ac1a7acd67b474a1848758589d4613065","head":{"label":"mauro3:m3/scope-doc","ref":"m3/scope-doc","sha":"abdfc24ac1a7acd67b474a1848758589d4613065","user":{"login":"mauro3","id":4098145,"avatar_url":"https://avatars.githubusercontent.com/u/4098145?v=3","gravatar_id":"","url":"https://api.github.com/users/mauro3","html_url":"https://github.com/mauro3","followers_url":"https://api.github.com/users/mauro3/followers","following_url":"https://api.github.com/users/mauro3/following{/other_user}","gists_url":"https://api.github.com/users/mauro3/gists{/gist_id}","starred_url":"https://api.github.com/users/mauro3/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/mauro3/subscriptions","organizations_url":"https://api.github.com/users/mauro3/orgs","repos_url":"https://api.github.com/users/mauro3/repos","events_url":"https://api.github.com/users/mauro3/events{/privacy}","received_events_url":"https://api.github.com/users/mauro3/received_events","type":"User","site_admin":false},"repo":{"id":15839999,"name":"julia","full_name":"mauro3/julia","owner":{"login":"mauro3","id":4098145,"avatar_url":"https://avatars.githubusercontent.com/u/4098145?v=3","gravatar_id":"","url":"https://api.github.com/users/mauro3","html_url":"https://github.com/mauro3","followers_url":"https://api.github.com/users/mauro3/followers","following_url":"https://api.github.com/users/mauro3/following{/other_user}","gists_url":"https://api.github.com/users/mauro3/gists{/gist_id}","starred_url":"https://api.github.com/users/mauro3/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/mauro3/subscriptions","organizations_url":"https://api.github.com/users/mauro3/orgs","repos_url":"https://api.github.com/users/mauro3/repos","events_url":"https://api.github.com/users/mauro3/events{/privacy}","received_events_url":"https://api.github.com/users/mauro3/received_events","type":"User","site_admin":false},"private":false,"html_url":"https://github.com/mauro3/julia","description":"The Julia Language: A fresh approach to technical computing.","fork":true,"url":"https://api.github.com/repos/mauro3/julia","forks_url":"https://api.github.com/repos/mauro3/julia/forks","keys_url":"https://api.github.com/repos/mauro3/julia/keys{/key_id}","collaborators_url":"https://api.github.com/repos/mauro3/julia/collaborators{/collaborator}","teams_url":"https://api.github.com/repos/mauro3/julia/teams","hooks_url":"https://api.github.com/repos/mauro3/julia/hooks","issue_events_url":"https://api.github.com/repos/mauro3/julia/issues/events{/number}","events_url":"https://api.github.com/repos/mauro3/julia/events","assignees_url":"https://api.github.com/repos/mauro3/julia/assignees{/user}","branches_url":"https://api.github.com/repos/mauro3/julia/branches{/branch}","tags_url":"https://api.github.com/repos/mauro3/julia/tags","blobs_url":"https://api.github.com/repos/mauro3/julia/git/blobs{/sha}","git_tags_url":"https://api.github.com/repos/mauro3/julia/git/tags{/sha}","git_refs_url":"https://api.github.com/repos/mauro3/julia/git/refs{/sha}","trees_url":"https://api.github.com/repos/mauro3/julia/git/trees{/sha}","statuses_url":"https://api.github.com/repos/mauro3/julia/statuses/{sha}","languages_url":"https://api.github.com/repos/mauro3/julia/languages","stargazers_url":"https://api.github.com/repos/mauro3/julia/stargazers","contributors_url":"https://api.github.com/repos/mauro3/julia/contributors","subscribers_url":"https://api.github.com/repos/mauro3/julia/subscribers","subscription_url":"https://api.github.com/repos/mauro3/julia/subscription","commits_url":"https://api.github.com/repos/mauro3/julia/commits{/sha}","git_commits_url":"https://api.github.com/repos/mauro3/julia/git/commits{/sha}","comments_url":"https://api.github.com/repos/mauro3/julia/comments{/number}","issue_comment_url":"https://api.github.com/repos/mauro3/julia/issues/comments{/number}","contents_url":"https://api.github.com/repos/mauro3/julia/contents/{+path}","compare_url":"https://api.github.com/repos/mauro3/julia/compare/{base}...{head}","merges_url":"https://api.github.com/repos/mauro3/julia/merges","archive_url":"https://api.github.com/repos/mauro3/julia/{archive_format}{/ref}","downloads_url":"https://api.github.com/repos/mauro3/julia/downloads","issues_url":"https://api.github.com/repos/mauro3/julia/issues{/number}","pulls_url":"https://api.github.com/repos/mauro3/julia/pulls{/number}","milestones_url":"https://api.github.com/repos/mauro3/julia/milestones{/number}","notifications_url":"https://api.github.com/repos/mauro3/julia/notifications{?since,all,participating}","labels_url":"https://api.github.com/repos/mauro3/julia/labels{/name}","releases_url":"https://api.github.com/repos/mauro3/julia/releases{/id}","deployments_url":"https://api.github.com/repos/mauro3/julia/deployments","created_at":"2014-01-12T10:03:39Z","updated_at":"2015-04-22T08:32:13Z","pushed_at":"2015-11-05T16:27:21Z","git_url":"git://github.com/mauro3/julia.git","ssh_url":"git@github.com:mauro3/julia.git","clone_url":"https://github.com/mauro3/julia.git","svn_url":"https://github.com/mauro3/julia","homepage":"http://julialang.org/","size":84354,"stargazers_count":0,"watchers_count":0,"language":"Julia","has_issues":false,"has_downloads":true,"has_wiki":false,"has_pages":false,"forks_count":0,"mirror_url":null,"open_issues_count":0,"forks":0,"open_issues":0,"watchers":0,"default_branch":"master"}},"base":{"label":"JuliaLang:master","ref":"master","sha":"b122bc7d31eb0c25e9e88c819b9f1d07a803ffa9","user":{"login":"JuliaLang","id":743164,"avatar_url":"https://avatars.githubusercontent.com/u/743164?v=3","gravatar_id":"","url":"https://api.github.com/users/JuliaLang","html_url":"https://github.com/JuliaLang","followers_url":"https://api.github.com/users/JuliaLang/followers","following_url":"https://api.github.com/users/JuliaLang/following{/other_user}","gists_url":"https://api.github.com/users/JuliaLang/gists{/gist_id}","starred_url":"https://api.github.com/users/JuliaLang/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/JuliaLang/subscriptions","organizations_url":"https://api.github.com/users/JuliaLang/orgs","repos_url":"https://api.github.com/users/JuliaLang/repos","events_url":"https://api.github.com/users/JuliaLang/events{/privacy}","received_events_url":"https://api.github.com/users/JuliaLang/received_events","type":"Organization","site_admin":false},"repo":{"id":1644196,"name":"julia","full_name":"JuliaLang/julia","owner":{"login":"JuliaLang","id":743164,"avatar_url":"https://avatars.githubusercontent.com/u/743164?v=3","gravatar_id":"","url":"https://api.github.com/users/JuliaLang","html_url":"https://github.com/JuliaLang","followers_url":"https://api.github.com/users/JuliaLang/followers","following_url":"https://api.github.com/users/JuliaLang/following{/other_user}","gists_url":"https://api.github.com/users/JuliaLang/gists{/gist_id}","starred_url":"https://api.github.com/users/JuliaLang/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/JuliaLang/subscriptions","organizations_url":"https://api.github.com/users/JuliaLang/orgs","repos_url":"https://api.github.com/users/JuliaLang/repos","events_url":"https://api.github.com/users/JuliaLang/events{/privacy}","received_events_url":"https://api.github.com/users/JuliaLang/received_events","type":"Organization","site_admin":false},"private":false,"html_url":"https://github.com/JuliaLang/julia","description":"The Julia Language: A fresh approach to technical computing.","fork":false,"url":"https://api.github.com/repos/JuliaLang/julia","forks_url":"https://api.github.com/repos/JuliaLang/julia/forks","keys_url":"https://api.github.com/repos/JuliaLang/julia/keys{/key_id}","collaborators_url":"https://api.github.com/repos/JuliaLang/julia/collaborators{/collaborator}","teams_url":"https://api.github.com/repos/JuliaLang/julia/teams","hooks_url":"https://api.github.com/repos/JuliaLang/julia/hooks","issue_events_url":"https://api.github.com/repos/JuliaLang/julia/issues/events{/number}","events_url":"https://api.github.com/repos/JuliaLang/julia/events","assignees_url":"https://api.github.com/repos/JuliaLang/julia/assignees{/user}","branches_url":"https://api.github.com/repos/JuliaLang/julia/branches{/branch}","tags_url":"https://api.github.com/repos/JuliaLang/julia/tags","blobs_url":"https://api.github.com/repos/JuliaLang/julia/git/blobs{/sha}","git_tags_url":"https://api.github.com/repos/JuliaLang/julia/git/tags{/sha}","git_refs_url":"https://api.github.com/repos/JuliaLang/julia/git/refs{/sha}","trees_url":"https://api.github.com/repos/JuliaLang/julia/git/trees{/sha}","statuses_url":"https://api.github.com/repos/JuliaLang/julia/statuses/{sha}","languages_url":"https://api.github.com/repos/JuliaLang/julia/languages","stargazers_url":"https://api.github.com/repos/JuliaLang/julia/stargazers","contributors_url":"https://api.github.com/repos/JuliaLang/julia/contributors","subscribers_url":"https://api.github.com/repos/JuliaLang/julia/subscribers","subscription_url":"https://api.github.com/repos/JuliaLang/julia/subscription","commits_url":"https://api.github.com/repos/JuliaLang/julia/commits{/sha}","git_commits_url":"https://api.github.com/repos/JuliaLang/julia/git/commits{/sha}","comments_url":"https://api.github.com/repos/JuliaLang/julia/comments{/number}","issue_comment_url":"https://api.github.com/repos/JuliaLang/julia/issues/comments{/number}","contents_url":"https://api.github.com/repos/JuliaLang/julia/contents/{+path}","compare_url":"https://api.github.com/repos/JuliaLang/julia/compare/{base}...{head}","merges_url":"https://api.github.com/repos/JuliaLang/julia/merges","archive_url":"https://api.github.com/repos/JuliaLang/julia/{archive_format}{/ref}","downloads_url":"https://api.github.com/repos/JuliaLang/julia/downloads","issues_url":"https://api.github.com/repos/JuliaLang/julia/issues{/number}","pulls_url":"https://api.github.com/repos/JuliaLang/julia/pulls{/number}","milestones_url":"https://api.github.com/repos/JuliaLang/julia/milestones{/number}","notifications_url":"https://api.github.com/repos/JuliaLang/julia/notifications{?since,all,participating}","labels_url":"https://api.github.com/repos/JuliaLang/julia/labels{/name}","releases_url":"https://api.github.com/repos/JuliaLang/julia/releases{/id}","deployments_url":"https://api.github.com/repos/JuliaLang/julia/deployments","created_at":"2011-04-21T07:01:50Z","updated_at":"2016-02-01T11:36:42Z","pushed_at":"2016-02-01T14:21:56Z","git_url":"git://github.com/JuliaLang/julia.git","ssh_url":"git@github.com:JuliaLang/julia.git","clone_url":"https://github.com/JuliaLang/julia.git","svn_url":"https://github.com/JuliaLang/julia","homepage":"http://julialang.org/","size":121135,"stargazers_count":6669,"watchers_count":6669,"language":"Julia","has_issues":true,"has_downloads":true,"has_wiki":false,"has_pages":false,"forks_count":1495,"mirror_url":null,"open_issues_count":1627,"forks":1495,"open_issues":1627,"watchers":6669,"default_branch":"master"}},"_links":{"self":{"href":"https://api.github.com/repos/JuliaLang/julia/pulls/12146"},"html":{"href":"https://github.com/JuliaLang/julia/pull/12146"},"issue":{"href":"https://api.github.com/repos/JuliaLang/julia/issues/12146"},"comments":{"href":"https://api.github.com/repos/JuliaLang/julia/issues/12146/comments"},"review_comments":{"href":"https://api.github.com/repos/JuliaLang/julia/pulls/12146/comments"},"review_comment":{"href":"https://api.github.com/repos/JuliaLang/julia/pulls/comments{/number}"},"commits":{"href":"https://api.github.com/repos/JuliaLang/julia/pulls/12146/commits"},"statuses":{"href":"https://api.github.com/repos/JuliaLang/julia/statuses/abdfc24ac1a7acd67b474a1848758589d4613065"}}}}